From e69e8e6817fdca4808aab5746f7352175d4a672b Mon Sep 17 00:00:00 2001 From: Kenny Kerr Date: Thu, 11 Jan 2024 08:33:06 -0600 Subject: [PATCH] Add `VARIANT` and `PROPVARIANT` support (#2786) --- .github/workflows/clippy.yml | 1 + .github/workflows/test.yml | 3 +- crates/libs/bindgen/src/lib.rs | 2 +- crates/libs/bindgen/src/metadata.rs | 6 +- crates/libs/bindgen/src/rust/mod.rs | 6 +- crates/libs/bindgen/src/rust/writer.rs | 14 + crates/libs/core/src/imp/bindings.rs | 950 ++++ crates/libs/core/src/lib.rs | 2 + crates/libs/core/src/variant.rs | 546 +++ crates/libs/metadata/src/reader.rs | 45 +- crates/libs/metadata/src/type.rs | 2 + crates/libs/metadata/src/type_name.rs | 3 + .../src/Windows/Wdk/Graphics/Direct3D/mod.rs | 40 +- .../src/Windows/Win32/Data/HtmlHelp/mod.rs | 18 +- .../src/Windows/Win32/Data/Xml/MsXml/impl.rs | 864 ++-- .../src/Windows/Win32/Data/Xml/MsXml/mod.rs | 1908 ++++---- .../Win32/Devices/Enumeration/Pnp/impl.rs | 92 +- .../Win32/Devices/Enumeration/Pnp/mod.rs | 86 +- .../src/Windows/Win32/Devices/Fax/impl.rs | 572 +-- .../src/Windows/Win32/Devices/Fax/mod.rs | 374 +- .../Win32/Devices/FunctionDiscovery/impl.rs | 48 +- .../Win32/Devices/FunctionDiscovery/mod.rs | 82 +- .../Windows/Win32/Devices/Geolocation/impl.rs | 84 +- .../Windows/Win32/Devices/Geolocation/mod.rs | 24 +- .../Win32/Devices/ImageAcquisition/impl.rs | 20 +- .../Win32/Devices/ImageAcquisition/mod.rs | 42 +- .../Win32/Devices/PortableDevices/impl.rs | 40 +- .../Win32/Devices/PortableDevices/mod.rs | 62 +- .../src/Windows/Win32/Devices/Sensors/impl.rs | 24 +- .../src/Windows/Win32/Devices/Sensors/mod.rs | 228 +- .../src/Windows/Win32/Devices/Tapi/impl.rs | 896 ++-- .../src/Windows/Win32/Devices/Tapi/mod.rs | 521 +- .../Windows/Win32/Graphics/Imaging/impl.rs | 60 +- .../src/Windows/Win32/Graphics/Imaging/mod.rs | 106 +- .../Windows/Win32/Graphics/Printing/impl.rs | 284 +- .../Windows/Win32/Graphics/Printing/mod.rs | 40 +- .../src/Windows/Win32/Media/Audio/impl.rs | 36 +- .../src/Windows/Win32/Media/Audio/mod.rs | 69 +- .../Windows/Win32/Media/DeviceManager/impl.rs | 32 +- .../Windows/Win32/Media/DeviceManager/mod.rs | 111 +- .../Windows/Win32/Media/DirectShow/Tv/impl.rs | 1122 +++-- .../Windows/Win32/Media/DirectShow/Tv/mod.rs | 753 ++- .../Windows/Win32/Media/DirectShow/impl.rs | 244 +- .../src/Windows/Win32/Media/DirectShow/mod.rs | 138 +- .../Media/LibrarySharingServices/impl.rs | 44 +- .../Win32/Media/LibrarySharingServices/mod.rs | 9 +- .../Win32/Media/MediaFoundation/impl.rs | 324 +- .../Win32/Media/MediaFoundation/mod.rs | 822 +--- .../Windows/Win32/Media/MediaPlayer/impl.rs | 492 +- .../Windows/Win32/Media/MediaPlayer/mod.rs | 202 +- .../Win32/Media/PictureAcquisition/impl.rs | 36 +- .../Win32/Media/PictureAcquisition/mod.rs | 48 +- .../src/Windows/Win32/Media/Speech/impl.rs | 676 ++- .../src/Windows/Win32/Media/Speech/mod.rs | 797 ++-- .../Win32/Media/WindowsMediaFormat/impl.rs | 8 +- .../Win32/Media/WindowsMediaFormat/mod.rs | 9 +- .../NetworkManagement/MobileBroadband/impl.rs | 8 +- .../NetworkPolicyServer/impl.rs | 80 +- .../NetworkPolicyServer/mod.rs | 79 +- .../NetworkManagement/WindowsFirewall/impl.rs | 336 +- .../NetworkManagement/WindowsFirewall/mod.rs | 153 +- .../Win32/Networking/ActiveDirectory/impl.rs | 892 ++-- .../Win32/Networking/ActiveDirectory/mod.rs | 2014 +++----- .../impl.rs | 28 +- .../mod.rs | 20 +- .../Win32/Networking/Clustering/impl.rs | 596 +-- .../Win32/Networking/Clustering/mod.rs | 925 ++-- .../Networking/NetworkListManager/impl.rs | 56 +- .../Windows/Win32/Networking/WinHttp/impl.rs | 40 +- .../Windows/Win32/Networking/WinHttp/mod.rs | 96 +- .../Authentication/Identity/Provider/impl.rs | 88 +- .../Authentication/Identity/Provider/mod.rs | 120 +- .../Win32/Security/Authorization/impl.rs | 1027 ++-- .../Win32/Security/Authorization/mod.rs | 4190 +++++++---------- .../Cryptography/Certificates/impl.rs | 1328 +++--- .../Security/Cryptography/Certificates/mod.rs | 549 +-- .../Win32/Security/Cryptography/impl.rs | 128 +- .../Win32/Security/Cryptography/mod.rs | 197 +- .../Win32/Storage/DataDeduplication/impl.rs | 8 +- .../Win32/Storage/DataDeduplication/mod.rs | 14 +- .../Storage/FileServerResourceManager/impl.rs | 652 +-- .../Storage/FileServerResourceManager/mod.rs | 573 +-- .../src/Windows/Win32/Storage/Imapi/impl.rs | 352 +- .../Windows/Win32/Storage/IndexServer/impl.rs | 12 +- .../Windows/Win32/Storage/IndexServer/mod.rs | 9 +- .../Win32/Storage/OfflineFiles/impl.rs | 20 +- .../Windows/Win32/Storage/OfflineFiles/mod.rs | 44 +- .../src/Windows/Win32/Storage/Vss/impl.rs | 16 +- .../src/Windows/Win32/Storage/Vss/mod.rs | 28 +- .../Win32/Storage/Xps/Printing/impl.rs | 8 +- .../impl.rs | 56 +- .../Win32/System/AssessmentTool/impl.rs | 44 +- .../Win32/System/AssessmentTool/mod.rs | 203 +- .../Windows/Win32/System/ClrHosting/impl.rs | 8 +- .../Windows/Win32/System/ClrHosting/mod.rs | 9 +- .../Windows/Win32/System/Com/CallObj/impl.rs | 12 +- .../Windows/Win32/System/Com/CallObj/mod.rs | 22 +- .../System/Com/ChannelCredentials/impl.rs | 12 +- .../System/Com/ChannelCredentials/mod.rs | 24 +- .../Windows/Win32/System/Com/Events/impl.rs | 76 +- .../Windows/Win32/System/Com/Events/mod.rs | 100 +- .../System/Com/StructuredStorage/impl.rs | 40 +- .../Win32/System/Com/StructuredStorage/mod.rs | 884 ++-- .../src/Windows/Win32/System/Com/impl.rs | 40 +- .../src/Windows/Win32/System/Com/mod.rs | 150 +- .../Win32/System/ComponentServices/impl.rs | 464 +- .../Win32/System/ComponentServices/mod.rs | 539 +-- .../Win32/System/DeploymentServices/impl.rs | 200 +- .../Win32/System/DesktopSharing/impl.rs | 168 +- .../Win32/System/DesktopSharing/mod.rs | 55 +- .../Diagnostics/Debug/ActiveScript/impl.rs | 84 +- .../Diagnostics/Debug/ActiveScript/mod.rs | 120 +- .../Diagnostics/Debug/Extensions/impl.rs | 76 +- .../Diagnostics/Debug/Extensions/mod.rs | 116 +- .../Win32/System/Diagnostics/Debug/impl.rs | 24 +- .../Win32/System/Diagnostics/Debug/mod.rs | 59 +- .../System/EventNotificationService/impl.rs | 32 +- .../Windows/Win32/System/GroupPolicy/impl.rs | 517 +- .../Windows/Win32/System/GroupPolicy/mod.rs | 628 ++- .../src/Windows/Win32/System/Js/mod.rs | 16 +- .../Win32/System/MessageQueuing/impl.rs | 1116 +++-- .../Win32/System/MessageQueuing/mod.rs | 2327 ++++----- .../src/Windows/Win32/System/Mmc/impl.rs | 236 +- .../src/Windows/Win32/System/Mmc/mod.rs | 207 +- .../src/Windows/Win32/System/Ole/impl.rs | 148 +- .../src/Windows/Win32/System/Ole/mod.rs | 479 +- .../Windows/Win32/System/Performance/impl.rs | 324 +- .../Windows/Win32/System/Performance/mod.rs | 395 +- .../System/RealTimeCommunications/impl.rs | 288 +- .../System/RealTimeCommunications/mod.rs | 99 +- .../Win32/System/RemoteAssistance/impl.rs | 8 +- .../Win32/System/RemoteDesktop/impl.rs | 184 +- .../Windows/Win32/System/RemoteDesktop/mod.rs | 188 +- .../Win32/System/RemoteManagement/impl.rs | 124 +- .../Win32/System/RemoteManagement/mod.rs | 128 +- .../src/Windows/Win32/System/Search/impl.rs | 468 +- .../src/Windows/Win32/System/Search/mod.rs | 1063 ++--- .../Win32/System/SecurityCenter/impl.rs | 40 +- .../SettingsManagementInfrastructure/impl.rs | 56 +- .../SettingsManagementInfrastructure/mod.rs | 88 +- .../src/Windows/Win32/System/SideShow/impl.rs | 32 +- .../src/Windows/Win32/System/SideShow/mod.rs | 44 +- .../Win32/System/TaskScheduler/impl.rs | 372 +- .../Windows/Win32/System/TaskScheduler/mod.rs | 204 +- .../Win32/System/TransactionServer/impl.rs | 40 +- .../Windows/Win32/System/UpdateAgent/impl.rs | 612 +-- .../Windows/Win32/System/UpdateAgent/mod.rs | 268 +- .../src/Windows/Win32/System/Variant/mod.rs | 799 +--- .../Win32/System/WinRT/Metadata/impl.rs | 16 +- .../Win32/System/WinRT/Metadata/mod.rs | 22 +- .../Windows/Win32/System/WindowsSync/impl.rs | 16 +- .../Windows/Win32/System/WindowsSync/mod.rs | 28 +- .../src/Windows/Win32/System/Wmi/impl.rs | 348 +- .../src/Windows/Win32/System/Wmi/mod.rs | 295 +- .../Windows/Win32/UI/Accessibility/impl.rs | 398 +- .../src/Windows/Win32/UI/Accessibility/mod.rs | 1114 ++--- .../Win32/UI/Controls/RichEdit/impl.rs | 184 +- .../Windows/Win32/UI/Controls/RichEdit/mod.rs | 331 +- .../src/Windows/Win32/UI/Ribbon/impl.rs | 44 +- .../src/Windows/Win32/UI/Ribbon/mod.rs | 62 +- .../Win32/UI/Shell/PropertiesSystem/impl.rs | 152 +- .../Win32/UI/Shell/PropertiesSystem/mod.rs | 419 +- .../src/Windows/Win32/UI/Shell/impl.rs | 834 ++-- .../windows/src/Windows/Win32/UI/Shell/mod.rs | 2389 ++++------ .../src/Windows/Win32/UI/TabletPC/impl.rs | 668 +-- .../src/Windows/Win32/UI/TabletPC/mod.rs | 779 ++- .../src/Windows/Win32/UI/TextServices/impl.rs | 100 +- .../src/Windows/Win32/UI/TextServices/mod.rs | 156 +- .../Win32/Web/InternetExplorer/impl.rs | 164 +- .../Windows/Win32/Web/InternetExplorer/mod.rs | 136 +- crates/tests/implement/tests/properties.rs | 21 +- crates/tests/metadata/tests/unused.rs | 1 + crates/tests/variant/Cargo.toml | 8 + crates/tests/variant/src/lib.rs | 1 + crates/tests/variant/tests/tests.rs | 193 + crates/tools/core/bindings.txt | 43 +- 176 files changed, 23588 insertions(+), 29202 deletions(-) create mode 100644 crates/libs/core/src/variant.rs create mode 100644 crates/tests/variant/Cargo.toml create mode 100644 crates/tests/variant/src/lib.rs create mode 100644 crates/tests/variant/tests/tests.rs diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index 5a0cccd159..e5ac894355 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -121,6 +121,7 @@ jobs: cargo clippy -p test_sys && cargo clippy -p test_targets && cargo clippy -p test_unions && + cargo clippy -p test_variant && cargo clippy -p test_wdk && cargo clippy -p test_weak && cargo clippy -p test_weak_ref && diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index ce1da057fc..f945de9eeb 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -100,8 +100,8 @@ jobs: cargo test -p test_enums && cargo test -p test_error && cargo test -p test_event && - cargo clean && cargo test -p test_extensions && + cargo clean && cargo test -p test_handles && cargo test -p test_helpers && cargo test -p test_implement && @@ -129,6 +129,7 @@ jobs: cargo test -p test_sys && cargo test -p test_targets && cargo test -p test_unions && + cargo test -p test_variant && cargo test -p test_wdk && cargo test -p test_weak && cargo test -p test_weak_ref && diff --git a/crates/libs/bindgen/src/lib.rs b/crates/libs/bindgen/src/lib.rs index 5a8b5ef1f7..91f19df2e1 100644 --- a/crates/libs/bindgen/src/lib.rs +++ b/crates/libs/bindgen/src/lib.rs @@ -104,7 +104,7 @@ where let output = canonicalize(output)?; let input = read_input(&input)?; - let reader = metadata::Reader::filter(input, &include, &exclude); + let reader = metadata::Reader::filter(input, &include, &exclude, &config); winmd::verify(reader)?; diff --git a/crates/libs/bindgen/src/metadata.rs b/crates/libs/bindgen/src/metadata.rs index ec62c1bb13..b966e20494 100644 --- a/crates/libs/bindgen/src/metadata.rs +++ b/crates/libs/bindgen/src/metadata.rs @@ -366,7 +366,7 @@ fn method_def_last_error(row: MethodDef) -> bool { pub fn type_is_borrowed(ty: &Type) -> bool { match ty { Type::TypeDef(row, _) => !type_def_is_blittable(*row), - Type::BSTR | Type::PCSTR | Type::PCWSTR | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => true, + Type::BSTR | Type::VARIANT | Type::PROPVARIANT | Type::PCSTR | Type::PCWSTR | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => true, _ => false, } } @@ -495,7 +495,7 @@ pub fn field_is_copyable(row: Field, enclosing: TypeDef) -> bool { pub fn type_is_blittable(ty: &Type) -> bool { match ty { Type::TypeDef(row, _) => type_def_is_blittable(*row), - Type::String | Type::BSTR | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => false, + Type::String | Type::BSTR | Type::VARIANT | Type::PROPVARIANT | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => false, Type::Win32Array(kind, _) => type_is_blittable(kind), Type::WinrtArray(kind) => type_is_blittable(kind), _ => true, @@ -505,7 +505,7 @@ pub fn type_is_blittable(ty: &Type) -> bool { fn type_is_copyable(ty: &Type) -> bool { match ty { Type::TypeDef(row, _) => type_def_is_copyable(*row), - Type::String | Type::BSTR | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => false, + Type::String | Type::BSTR | Type::VARIANT | Type::PROPVARIANT | Type::IInspectable | Type::IUnknown | Type::GenericParam(_) => false, Type::Win32Array(kind, _) => type_is_copyable(kind), Type::WinrtArray(kind) => type_is_copyable(kind), _ => true, diff --git a/crates/libs/bindgen/src/rust/mod.rs b/crates/libs/bindgen/src/rust/mod.rs index 2ddc2515a8..258ddf1614 100644 --- a/crates/libs/bindgen/src/rust/mod.rs +++ b/crates/libs/bindgen/src/rust/mod.rs @@ -168,10 +168,10 @@ fn namespace(writer: &Writer, tree: &Tree) -> String { match item { metadata::Item::Type(def) => { let type_name = def.type_name(); - if metadata::REMAP_TYPES.iter().any(|(x, _)| x == &type_name) { + if writer.reader.remap_types().any(|(x, _)| x == &type_name) { continue; } - if metadata::CORE_TYPES.iter().any(|(x, _)| x == &type_name) { + if writer.reader.core_types().any(|(x, _)| x == &type_name) { continue; } let name = type_name.name; @@ -241,7 +241,7 @@ fn namespace_impl(writer: &Writer, tree: &Tree) -> String { for item in writer.reader.namespace_items(tree.namespace) { if let metadata::Item::Type(def) = item { let type_name = def.type_name(); - if metadata::CORE_TYPES.iter().any(|(x, _)| x == &type_name) { + if writer.reader.core_types().any(|(x, _)| x == &type_name) { continue; } if def.kind() != metadata::TypeKind::Interface { diff --git a/crates/libs/bindgen/src/rust/writer.rs b/crates/libs/bindgen/src/rust/writer.rs index 90c5cc5fdb..5153f9a627 100644 --- a/crates/libs/bindgen/src/rust/writer.rs +++ b/crates/libs/bindgen/src/rust/writer.rs @@ -118,6 +118,14 @@ impl Writer { let crate_name = self.crate_name(); quote! { #crate_name BSTR } } + metadata::Type::VARIANT => { + let crate_name = self.crate_name(); + quote! { #crate_name VARIANT } + } + metadata::Type::PROPVARIANT => { + let crate_name = self.crate_name(); + quote! { #crate_name PROPVARIANT } + } metadata::Type::IInspectable => { let crate_name = self.crate_name(); quote! { #crate_name IInspectable } @@ -198,6 +206,12 @@ impl Writer { metadata::Type::BSTR => { quote! { ::std::mem::MaybeUninit<::windows_core::BSTR> } } + metadata::Type::VARIANT => { + quote! { ::std::mem::MaybeUninit<::windows_core::VARIANT> } + } + metadata::Type::PROPVARIANT => { + quote! { ::std::mem::MaybeUninit<::windows_core::PROPVARIANT> } + } metadata::Type::Win32Array(kind, len) => { let name = self.type_abi_name(kind); let len = Literal::usize_unsuffixed(*len); diff --git a/crates/libs/core/src/imp/bindings.rs b/crates/libs/core/src/imp/bindings.rs index 43aa01c714..e064629a52 100644 --- a/crates/libs/core/src/imp/bindings.rs +++ b/crates/libs/core/src/imp/bindings.rs @@ -16,28 +16,734 @@ ::windows_targets::link!("kernel32.dll" "system" fn WaitForSingleObject(hhandle : HANDLE, dwmilliseconds : u32) -> WAIT_EVENT); ::windows_targets::link!("ole32.dll" "system" fn CoTaskMemAlloc(cb : usize) -> *mut ::core::ffi::c_void); ::windows_targets::link!("ole32.dll" "system" fn CoTaskMemFree(pv : *const ::core::ffi::c_void)); +::windows_targets::link!("ole32.dll" "system" fn PropVariantClear(pvar : *mut PROPVARIANT) -> HRESULT); +::windows_targets::link!("ole32.dll" "system" fn PropVariantCopy(pvardest : *mut PROPVARIANT, pvarsrc : *const PROPVARIANT) -> HRESULT); ::windows_targets::link!("oleaut32.dll" "system" fn SysAllocStringLen(strin : PCWSTR, ui : u32) -> BSTR); ::windows_targets::link!("oleaut32.dll" "system" fn SysFreeString(bstrstring : BSTR)); ::windows_targets::link!("oleaut32.dll" "system" fn SysStringLen(pbstr : BSTR) -> u32); +::windows_targets::link!("oleaut32.dll" "system" fn VariantClear(pvarg : *mut VARIANT) -> HRESULT); +::windows_targets::link!("oleaut32.dll" "system" fn VariantCopy(pvargdest : *mut VARIANT, pvargsrc : *const VARIANT) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantCompareEx(propvar1 : *const PROPVARIANT, propvar2 : *const PROPVARIANT, unit : PROPVAR_COMPARE_UNIT, flags : PROPVAR_COMPARE_FLAGS) -> i32); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToBSTR(propvar : *const PROPVARIANT, pbstrout : *mut BSTR) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToBoolean(propvarin : *const PROPVARIANT, pfret : *mut BOOL) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToDouble(propvarin : *const PROPVARIANT, pdblret : *mut f64) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16(propvarin : *const PROPVARIANT, piret : *mut i16) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32(propvarin : *const PROPVARIANT, plret : *mut i32) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64(propvarin : *const PROPVARIANT, pllret : *mut i64) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16(propvarin : *const PROPVARIANT, puiret : *mut u16) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32(propvarin : *const PROPVARIANT, pulret : *mut u32) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64(propvarin : *const PROPVARIANT, pullret : *mut u64) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn PropVariantToVariant(ppropvar : *const PROPVARIANT, pvar : *mut VARIANT) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToBoolean(varin : *const VARIANT, pfret : *mut BOOL) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToDouble(varin : *const VARIANT, pdblret : *mut f64) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToInt16(varin : *const VARIANT, piret : *mut i16) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToInt32(varin : *const VARIANT, plret : *mut i32) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToInt64(varin : *const VARIANT, pllret : *mut i64) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToPropVariant(pvar : *const VARIANT, ppropvar : *mut PROPVARIANT) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16(varin : *const VARIANT, puiret : *mut u16) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32(varin : *const VARIANT, pulret : *mut u32) -> HRESULT); +::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64(varin : *const VARIANT, pullret : *mut u64) -> HRESULT); +pub type ADVANCED_FEATURE_FLAGS = u16; +#[repr(C)] +pub struct ARRAYDESC { + pub tdescElem: TYPEDESC, + pub cDims: u16, + pub rgbounds: [SAFEARRAYBOUND; 1], +} +impl ::core::marker::Copy for ARRAYDESC {} +impl ::core::clone::Clone for ARRAYDESC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union BINDPTR { + pub lpfuncdesc: *mut FUNCDESC, + pub lpvardesc: *mut VARDESC, + pub lptcomp: ITypeComp, +} +impl ::core::marker::Copy for BINDPTR {} +impl ::core::clone::Clone for BINDPTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct BLOB { + pub cbSize: u32, + pub pBlobData: *mut u8, +} +impl ::core::marker::Copy for BLOB {} +impl ::core::clone::Clone for BLOB { + fn clone(&self) -> Self { + *self + } +} pub type BOOL = i32; pub type BSTR = *const u16; +#[repr(C)] +pub struct BSTRBLOB { + pub cbSize: u32, + pub pData: *mut u8, +} +impl ::core::marker::Copy for BSTRBLOB {} +impl ::core::clone::Clone for BSTRBLOB { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CABOOL { + pub cElems: u32, + pub pElems: *mut VARIANT_BOOL, +} +impl ::core::marker::Copy for CABOOL {} +impl ::core::clone::Clone for CABOOL { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CABSTR { + pub cElems: u32, + pub pElems: *mut BSTR, +} +impl ::core::marker::Copy for CABSTR {} +impl ::core::clone::Clone for CABSTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CABSTRBLOB { + pub cElems: u32, + pub pElems: *mut BSTRBLOB, +} +impl ::core::marker::Copy for CABSTRBLOB {} +impl ::core::clone::Clone for CABSTRBLOB { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAC { + pub cElems: u32, + pub pElems: PSTR, +} +impl ::core::marker::Copy for CAC {} +impl ::core::clone::Clone for CAC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CACLIPDATA { + pub cElems: u32, + pub pElems: *mut CLIPDATA, +} +impl ::core::marker::Copy for CACLIPDATA {} +impl ::core::clone::Clone for CACLIPDATA { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CACLSID { + pub cElems: u32, + pub pElems: *mut GUID, +} +impl ::core::marker::Copy for CACLSID {} +impl ::core::clone::Clone for CACLSID { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CACY { + pub cElems: u32, + pub pElems: *mut CY, +} +impl ::core::marker::Copy for CACY {} +impl ::core::clone::Clone for CACY { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CADATE { + pub cElems: u32, + pub pElems: *mut f64, +} +impl ::core::marker::Copy for CADATE {} +impl ::core::clone::Clone for CADATE { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CADBL { + pub cElems: u32, + pub pElems: *mut f64, +} +impl ::core::marker::Copy for CADBL {} +impl ::core::clone::Clone for CADBL { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAFILETIME { + pub cElems: u32, + pub pElems: *mut FILETIME, +} +impl ::core::marker::Copy for CAFILETIME {} +impl ::core::clone::Clone for CAFILETIME { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAFLT { + pub cElems: u32, + pub pElems: *mut f32, +} +impl ::core::marker::Copy for CAFLT {} +impl ::core::clone::Clone for CAFLT { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAH { + pub cElems: u32, + pub pElems: *mut i64, +} +impl ::core::marker::Copy for CAH {} +impl ::core::clone::Clone for CAH { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAI { + pub cElems: u32, + pub pElems: *mut i16, +} +impl ::core::marker::Copy for CAI {} +impl ::core::clone::Clone for CAI { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAL { + pub cElems: u32, + pub pElems: *mut i32, +} +impl ::core::marker::Copy for CAL {} +impl ::core::clone::Clone for CAL { + fn clone(&self) -> Self { + *self + } +} +pub type CALLCONV = i32; +#[repr(C)] +pub struct CALPSTR { + pub cElems: u32, + pub pElems: *mut PSTR, +} +impl ::core::marker::Copy for CALPSTR {} +impl ::core::clone::Clone for CALPSTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CALPWSTR { + pub cElems: u32, + pub pElems: *mut PWSTR, +} +impl ::core::marker::Copy for CALPWSTR {} +impl ::core::clone::Clone for CALPWSTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAPROPVARIANT { + pub cElems: u32, + pub pElems: *mut PROPVARIANT, +} +impl ::core::marker::Copy for CAPROPVARIANT {} +impl ::core::clone::Clone for CAPROPVARIANT { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CASCODE { + pub cElems: u32, + pub pElems: *mut i32, +} +impl ::core::marker::Copy for CASCODE {} +impl ::core::clone::Clone for CASCODE { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAUB { + pub cElems: u32, + pub pElems: *mut u8, +} +impl ::core::marker::Copy for CAUB {} +impl ::core::clone::Clone for CAUB { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAUH { + pub cElems: u32, + pub pElems: *mut u64, +} +impl ::core::marker::Copy for CAUH {} +impl ::core::clone::Clone for CAUH { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAUI { + pub cElems: u32, + pub pElems: *mut u16, +} +impl ::core::marker::Copy for CAUI {} +impl ::core::clone::Clone for CAUI { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CAUL { + pub cElems: u32, + pub pElems: *mut u32, +} +impl ::core::marker::Copy for CAUL {} +impl ::core::clone::Clone for CAUL { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CLIPDATA { + pub cbSize: u32, + pub ulClipFmt: i32, + pub pClipData: *mut u8, +} +impl ::core::marker::Copy for CLIPDATA {} +impl ::core::clone::Clone for CLIPDATA { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union CY { + pub Anonymous: CY_0, + pub int64: i64, +} +impl ::core::marker::Copy for CY {} +impl ::core::clone::Clone for CY { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct CY_0 { + pub Lo: u32, + pub Hi: i32, +} +impl ::core::marker::Copy for CY_0 {} +impl ::core::clone::Clone for CY_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct DECIMAL { + pub wReserved: u16, + pub Anonymous1: DECIMAL_0, + pub Hi32: u32, + pub Anonymous2: DECIMAL_1, +} +impl ::core::marker::Copy for DECIMAL {} +impl ::core::clone::Clone for DECIMAL { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union DECIMAL_0 { + pub Anonymous: DECIMAL_0_0, + pub signscale: u16, +} +impl ::core::marker::Copy for DECIMAL_0 {} +impl ::core::clone::Clone for DECIMAL_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct DECIMAL_0_0 { + pub scale: u8, + pub sign: u8, +} +impl ::core::marker::Copy for DECIMAL_0_0 {} +impl ::core::clone::Clone for DECIMAL_0_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union DECIMAL_1 { + pub Anonymous: DECIMAL_1_0, + pub Lo64: u64, +} +impl ::core::marker::Copy for DECIMAL_1 {} +impl ::core::clone::Clone for DECIMAL_1 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct DECIMAL_1_0 { + pub Lo32: u32, + pub Mid32: u32, +} +impl ::core::marker::Copy for DECIMAL_1_0 {} +impl ::core::clone::Clone for DECIMAL_1_0 { + fn clone(&self) -> Self { + *self + } +} +pub type DESCKIND = i32; +pub type DISPATCH_FLAGS = u16; +#[repr(C)] +pub struct DISPPARAMS { + pub rgvarg: *mut VARIANT, + pub rgdispidNamedArgs: *mut i32, + pub cArgs: u32, + pub cNamedArgs: u32, +} +impl ::core::marker::Copy for DISPPARAMS {} +impl ::core::clone::Clone for DISPPARAMS { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct ELEMDESC { + pub tdesc: TYPEDESC, + pub Anonymous: ELEMDESC_0, +} +impl ::core::marker::Copy for ELEMDESC {} +impl ::core::clone::Clone for ELEMDESC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union ELEMDESC_0 { + pub idldesc: IDLDESC, + pub paramdesc: PARAMDESC, +} +impl ::core::marker::Copy for ELEMDESC_0 {} +impl ::core::clone::Clone for ELEMDESC_0 { + fn clone(&self) -> Self { + *self + } +} pub const ERROR_NO_UNICODE_TRANSLATION: WIN32_ERROR = 1113u32; +#[repr(C)] +pub struct EXCEPINFO { + pub wCode: u16, + pub wReserved: u16, + pub bstrSource: BSTR, + pub bstrDescription: BSTR, + pub bstrHelpFile: BSTR, + pub dwHelpContext: u32, + pub pvReserved: *mut ::core::ffi::c_void, + pub pfnDeferredFillIn: LPEXCEPFINO_DEFERRED_FILLIN, + pub scode: i32, +} +impl ::core::marker::Copy for EXCEPINFO {} +impl ::core::clone::Clone for EXCEPINFO { + fn clone(&self) -> Self { + *self + } +} pub const E_INVALIDARG: HRESULT = -2147024809i32; pub type FARPROC = ::core::option::Option isize>; +#[repr(C)] +pub struct FILETIME { + pub dwLowDateTime: u32, + pub dwHighDateTime: u32, +} +impl ::core::marker::Copy for FILETIME {} +impl ::core::clone::Clone for FILETIME { + fn clone(&self) -> Self { + *self + } +} pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: FORMAT_MESSAGE_OPTIONS = 256u32; pub const FORMAT_MESSAGE_FROM_SYSTEM: FORMAT_MESSAGE_OPTIONS = 4096u32; pub const FORMAT_MESSAGE_IGNORE_INSERTS: FORMAT_MESSAGE_OPTIONS = 512u32; pub type FORMAT_MESSAGE_OPTIONS = u32; +#[repr(C)] +pub struct FUNCDESC { + pub memid: i32, + pub lprgscode: *mut i32, + pub lprgelemdescParam: *mut ELEMDESC, + pub funckind: FUNCKIND, + pub invkind: INVOKEKIND, + pub callconv: CALLCONV, + pub cParams: i16, + pub cParamsOpt: i16, + pub oVft: i16, + pub cScodes: i16, + pub elemdescFunc: ELEMDESC, + pub wFuncFlags: FUNCFLAGS, +} +impl ::core::marker::Copy for FUNCDESC {} +impl ::core::clone::Clone for FUNCDESC { + fn clone(&self) -> Self { + *self + } +} +pub type FUNCFLAGS = u16; +pub type FUNCKIND = i32; +#[repr(C)] +pub struct GUID { + pub data1: u32, + pub data2: u16, + pub data3: u16, + pub data4: [u8; 8], +} +impl ::core::marker::Copy for GUID {} +impl ::core::clone::Clone for GUID { + fn clone(&self) -> Self { + *self + } +} +impl GUID { + pub const fn from_u128(uuid: u128) -> Self { + Self { data1: (uuid >> 96) as u32, data2: (uuid >> 80 & 0xffff) as u16, data3: (uuid >> 64 & 0xffff) as u16, data4: (uuid as u64).to_be_bytes() } + } +} pub type HANDLE = isize; pub type HEAP_FLAGS = u32; pub type HMODULE = isize; pub type HRESULT = i32; +#[repr(C)] +pub struct IDLDESC { + pub dwReserved: usize, + pub wIDLFlags: IDLFLAGS, +} +impl ::core::marker::Copy for IDLDESC {} +impl ::core::clone::Clone for IDLDESC { + fn clone(&self) -> Self { + *self + } +} +pub type IDLFLAGS = u16; +pub type IDispatch = *mut ::core::ffi::c_void; +pub type IEnumSTATSTG = *mut ::core::ffi::c_void; +pub type IMPLTYPEFLAGS = i32; +pub type INVOKEKIND = i32; +pub type IRecordInfo = *mut ::core::ffi::c_void; +pub type ISequentialStream = *mut ::core::ffi::c_void; +pub type IStorage = *mut ::core::ffi::c_void; +pub type IStream = *mut ::core::ffi::c_void; +pub type ITypeComp = *mut ::core::ffi::c_void; +pub type ITypeInfo = *mut ::core::ffi::c_void; +pub type ITypeLib = *mut ::core::ffi::c_void; +pub type IUnknown = *mut ::core::ffi::c_void; pub type LOAD_LIBRARY_FLAGS = u32; pub const LOAD_LIBRARY_SEARCH_DEFAULT_DIRS: LOAD_LIBRARY_FLAGS = 4096u32; +pub type LPEXCEPFINO_DEFERRED_FILLIN = ::core::option::Option HRESULT>; +#[repr(C)] +pub struct PARAMDESC { + pub pparamdescex: *mut PARAMDESCEX, + pub wParamFlags: PARAMFLAGS, +} +impl ::core::marker::Copy for PARAMDESC {} +impl ::core::clone::Clone for PARAMDESC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct PARAMDESCEX { + pub cBytes: u32, + pub varDefaultValue: VARIANT, +} +impl ::core::marker::Copy for PARAMDESCEX {} +impl ::core::clone::Clone for PARAMDESCEX { + fn clone(&self) -> Self { + *self + } +} +pub type PARAMFLAGS = u16; pub type PCSTR = *const u8; pub type PCWSTR = *const u16; +#[repr(C)] +pub struct PROPVARIANT { + pub Anonymous: PROPVARIANT_0, +} +impl ::core::marker::Copy for PROPVARIANT {} +impl ::core::clone::Clone for PROPVARIANT { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union PROPVARIANT_0 { + pub Anonymous: PROPVARIANT_0_0, + pub decVal: DECIMAL, +} +impl ::core::marker::Copy for PROPVARIANT_0 {} +impl ::core::clone::Clone for PROPVARIANT_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct PROPVARIANT_0_0 { + pub vt: VARENUM, + pub wReserved1: u16, + pub wReserved2: u16, + pub wReserved3: u16, + pub Anonymous: PROPVARIANT_0_0_0, +} +impl ::core::marker::Copy for PROPVARIANT_0_0 {} +impl ::core::clone::Clone for PROPVARIANT_0_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union PROPVARIANT_0_0_0 { + pub cVal: i8, + pub bVal: u8, + pub iVal: i16, + pub uiVal: u16, + pub lVal: i32, + pub ulVal: u32, + pub intVal: i32, + pub uintVal: u32, + pub hVal: i64, + pub uhVal: u64, + pub fltVal: f32, + pub dblVal: f64, + pub boolVal: VARIANT_BOOL, + pub __OBSOLETE__VARIANT_BOOL: VARIANT_BOOL, + pub scode: i32, + pub cyVal: CY, + pub date: f64, + pub filetime: FILETIME, + pub puuid: *mut GUID, + pub pclipdata: *mut CLIPDATA, + pub bstrVal: BSTR, + pub bstrblobVal: BSTRBLOB, + pub blob: BLOB, + pub pszVal: PSTR, + pub pwszVal: PWSTR, + pub punkVal: IUnknown, + pub pdispVal: IDispatch, + pub pStream: IStream, + pub pStorage: IStorage, + pub pVersionedStream: *mut VERSIONEDSTREAM, + pub parray: *mut SAFEARRAY, + pub cac: CAC, + pub caub: CAUB, + pub cai: CAI, + pub caui: CAUI, + pub cal: CAL, + pub caul: CAUL, + pub cah: CAH, + pub cauh: CAUH, + pub caflt: CAFLT, + pub cadbl: CADBL, + pub cabool: CABOOL, + pub cascode: CASCODE, + pub cacy: CACY, + pub cadate: CADATE, + pub cafiletime: CAFILETIME, + pub cauuid: CACLSID, + pub caclipdata: CACLIPDATA, + pub cabstr: CABSTR, + pub cabstrblob: CABSTRBLOB, + pub calpstr: CALPSTR, + pub calpwstr: CALPWSTR, + pub capropvar: CAPROPVARIANT, + pub pcVal: PSTR, + pub pbVal: *mut u8, + pub piVal: *mut i16, + pub puiVal: *mut u16, + pub plVal: *mut i32, + pub pulVal: *mut u32, + pub pintVal: *mut i32, + pub puintVal: *mut u32, + pub pfltVal: *mut f32, + pub pdblVal: *mut f64, + pub pboolVal: *mut VARIANT_BOOL, + pub pdecVal: *mut DECIMAL, + pub pscode: *mut i32, + pub pcyVal: *mut CY, + pub pdate: *mut f64, + pub pbstrVal: *mut BSTR, + pub ppunkVal: *mut IUnknown, + pub ppdispVal: *mut IDispatch, + pub pparray: *mut *mut SAFEARRAY, + pub pvarVal: *mut PROPVARIANT, +} +impl ::core::marker::Copy for PROPVARIANT_0_0_0 {} +impl ::core::clone::Clone for PROPVARIANT_0_0_0 { + fn clone(&self) -> Self { + *self + } +} +pub type PROPVAR_COMPARE_FLAGS = i32; +pub type PROPVAR_COMPARE_UNIT = i32; +pub type PSTR = *mut u8; pub type PWSTR = *mut u16; #[repr(C)] +pub struct SAFEARRAY { + pub cDims: u16, + pub fFeatures: ADVANCED_FEATURE_FLAGS, + pub cbElements: u32, + pub cLocks: u32, + pub pvData: *mut ::core::ffi::c_void, + pub rgsabound: [SAFEARRAYBOUND; 1], +} +impl ::core::marker::Copy for SAFEARRAY {} +impl ::core::clone::Clone for SAFEARRAY { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct SAFEARRAYBOUND { + pub cElements: u32, + pub lLbound: i32, +} +impl ::core::marker::Copy for SAFEARRAYBOUND {} +impl ::core::clone::Clone for SAFEARRAYBOUND { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] pub struct SECURITY_ATTRIBUTES { pub nLength: u32, pub lpSecurityDescriptor: *mut ::core::ffi::c_void, @@ -49,5 +755,249 @@ impl ::core::clone::Clone for SECURITY_ATTRIBUTES { *self } } +#[repr(C)] +pub struct STATSTG { + pub pwcsName: PWSTR, + pub r#type: u32, + pub cbSize: u64, + pub mtime: FILETIME, + pub ctime: FILETIME, + pub atime: FILETIME, + pub grfMode: STGM, + pub grfLocksSupported: u32, + pub clsid: GUID, + pub grfStateBits: u32, + pub reserved: u32, +} +impl ::core::marker::Copy for STATSTG {} +impl ::core::clone::Clone for STATSTG { + fn clone(&self) -> Self { + *self + } +} +pub type STGM = u32; +pub type STREAM_SEEK = u32; +pub type SYSKIND = i32; +#[repr(C)] +pub struct TLIBATTR { + pub guid: GUID, + pub lcid: u32, + pub syskind: SYSKIND, + pub wMajorVerNum: u16, + pub wMinorVerNum: u16, + pub wLibFlags: u16, +} +impl ::core::marker::Copy for TLIBATTR {} +impl ::core::clone::Clone for TLIBATTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct TYPEATTR { + pub guid: GUID, + pub lcid: u32, + pub dwReserved: u32, + pub memidConstructor: i32, + pub memidDestructor: i32, + pub lpstrSchema: PWSTR, + pub cbSizeInstance: u32, + pub typekind: TYPEKIND, + pub cFuncs: u16, + pub cVars: u16, + pub cImplTypes: u16, + pub cbSizeVft: u16, + pub cbAlignment: u16, + pub wTypeFlags: u16, + pub wMajorVerNum: u16, + pub wMinorVerNum: u16, + pub tdescAlias: TYPEDESC, + pub idldescType: IDLDESC, +} +impl ::core::marker::Copy for TYPEATTR {} +impl ::core::clone::Clone for TYPEATTR { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct TYPEDESC { + pub Anonymous: TYPEDESC_0, + pub vt: VARENUM, +} +impl ::core::marker::Copy for TYPEDESC {} +impl ::core::clone::Clone for TYPEDESC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union TYPEDESC_0 { + pub lptdesc: *mut TYPEDESC, + pub lpadesc: *mut ARRAYDESC, + pub hreftype: u32, +} +impl ::core::marker::Copy for TYPEDESC_0 {} +impl ::core::clone::Clone for TYPEDESC_0 { + fn clone(&self) -> Self { + *self + } +} +pub type TYPEKIND = i32; +#[repr(C)] +pub struct VARDESC { + pub memid: i32, + pub lpstrSchema: PWSTR, + pub Anonymous: VARDESC_0, + pub elemdescVar: ELEMDESC, + pub wVarFlags: VARFLAGS, + pub varkind: VARKIND, +} +impl ::core::marker::Copy for VARDESC {} +impl ::core::clone::Clone for VARDESC { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union VARDESC_0 { + pub oInst: u32, + pub lpvarValue: *mut VARIANT, +} +impl ::core::marker::Copy for VARDESC_0 {} +impl ::core::clone::Clone for VARDESC_0 { + fn clone(&self) -> Self { + *self + } +} +pub type VARENUM = u16; +pub type VARFLAGS = u16; +#[repr(C)] +pub struct VARIANT { + pub Anonymous: VARIANT_0, +} +impl ::core::marker::Copy for VARIANT {} +impl ::core::clone::Clone for VARIANT { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union VARIANT_0 { + pub Anonymous: VARIANT_0_0, + pub decVal: DECIMAL, +} +impl ::core::marker::Copy for VARIANT_0 {} +impl ::core::clone::Clone for VARIANT_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct VARIANT_0_0 { + pub vt: VARENUM, + pub wReserved1: u16, + pub wReserved2: u16, + pub wReserved3: u16, + pub Anonymous: VARIANT_0_0_0, +} +impl ::core::marker::Copy for VARIANT_0_0 {} +impl ::core::clone::Clone for VARIANT_0_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub union VARIANT_0_0_0 { + pub llVal: i64, + pub lVal: i32, + pub bVal: u8, + pub iVal: i16, + pub fltVal: f32, + pub dblVal: f64, + pub boolVal: VARIANT_BOOL, + pub __OBSOLETE__VARIANT_BOOL: VARIANT_BOOL, + pub scode: i32, + pub cyVal: CY, + pub date: f64, + pub bstrVal: BSTR, + pub punkVal: IUnknown, + pub pdispVal: IDispatch, + pub parray: *mut SAFEARRAY, + pub pbVal: *mut u8, + pub piVal: *mut i16, + pub plVal: *mut i32, + pub pllVal: *mut i64, + pub pfltVal: *mut f32, + pub pdblVal: *mut f64, + pub pboolVal: *mut VARIANT_BOOL, + pub __OBSOLETE__VARIANT_PBOOL: *mut VARIANT_BOOL, + pub pscode: *mut i32, + pub pcyVal: *mut CY, + pub pdate: *mut f64, + pub pbstrVal: *mut BSTR, + pub ppunkVal: *mut IUnknown, + pub ppdispVal: *mut IDispatch, + pub pparray: *mut *mut SAFEARRAY, + pub pvarVal: *mut VARIANT, + pub byref: *mut ::core::ffi::c_void, + pub cVal: i8, + pub uiVal: u16, + pub ulVal: u32, + pub ullVal: u64, + pub intVal: i32, + pub uintVal: u32, + pub pdecVal: *mut DECIMAL, + pub pcVal: PSTR, + pub puiVal: *mut u16, + pub pulVal: *mut u32, + pub pullVal: *mut u64, + pub pintVal: *mut i32, + pub puintVal: *mut u32, + pub Anonymous: VARIANT_0_0_0_0, +} +impl ::core::marker::Copy for VARIANT_0_0_0 {} +impl ::core::clone::Clone for VARIANT_0_0_0 { + fn clone(&self) -> Self { + *self + } +} +#[repr(C)] +pub struct VARIANT_0_0_0_0 { + pub pvRecord: *mut ::core::ffi::c_void, + pub pRecInfo: IRecordInfo, +} +impl ::core::marker::Copy for VARIANT_0_0_0_0 {} +impl ::core::clone::Clone for VARIANT_0_0_0_0 { + fn clone(&self) -> Self { + *self + } +} +pub type VARIANT_BOOL = i16; +pub type VARKIND = i32; +#[repr(C)] +pub struct VERSIONEDSTREAM { + pub guidVersion: GUID, + pub pStream: IStream, +} +impl ::core::marker::Copy for VERSIONEDSTREAM {} +impl ::core::clone::Clone for VERSIONEDSTREAM { + fn clone(&self) -> Self { + *self + } +} +pub const VT_BOOL: VARENUM = 11u16; +pub const VT_BSTR: VARENUM = 8u16; +pub const VT_EMPTY: VARENUM = 0u16; +pub const VT_I1: VARENUM = 16u16; +pub const VT_I2: VARENUM = 2u16; +pub const VT_I4: VARENUM = 3u16; +pub const VT_I8: VARENUM = 20u16; +pub const VT_R4: VARENUM = 4u16; +pub const VT_R8: VARENUM = 5u16; +pub const VT_UI1: VARENUM = 17u16; +pub const VT_UI2: VARENUM = 18u16; +pub const VT_UI4: VARENUM = 19u16; +pub const VT_UI8: VARENUM = 21u16; pub type WAIT_EVENT = u32; pub type WIN32_ERROR = u32; diff --git a/crates/libs/core/src/lib.rs b/crates/libs/core/src/lib.rs index 64b9dc1888..c0cd6dedc1 100644 --- a/crates/libs/core/src/lib.rs +++ b/crates/libs/core/src/lib.rs @@ -27,6 +27,7 @@ mod scoped_interface; mod strings; mod r#type; mod unknown; +mod variant; mod weak; pub use agile_reference::*; @@ -45,6 +46,7 @@ pub use runtime_type::*; pub use scoped_interface::*; pub use strings::*; pub use unknown::*; +pub use variant::*; pub use weak::*; /// A specialized [`Result`] type that provides Windows error information. diff --git a/crates/libs/core/src/variant.rs b/crates/libs/core/src/variant.rs new file mode 100644 index 0000000000..93732291c4 --- /dev/null +++ b/crates/libs/core/src/variant.rs @@ -0,0 +1,546 @@ +use super::*; + +#[repr(transparent)] +pub struct VARIANT(imp::VARIANT); + +#[repr(transparent)] +pub struct PROPVARIANT(imp::PROPVARIANT); + +impl Default for VARIANT { + fn default() -> Self { + Self::new() + } +} + +impl Default for PROPVARIANT { + fn default() -> Self { + Self::new() + } +} + +impl Clone for VARIANT { + fn clone(&self) -> Self { + unsafe { + let mut value = Self::new(); + imp::VariantCopy(&mut value.0, &self.0); + value + } + } +} + +impl Clone for PROPVARIANT { + fn clone(&self) -> Self { + unsafe { + let mut value = Self::new(); + imp::PropVariantCopy(&mut value.0, &self.0); + value + } + } +} + +impl Drop for VARIANT { + fn drop(&mut self) { + unsafe { imp::VariantClear(&mut self.0) }; + } +} + +impl Drop for PROPVARIANT { + fn drop(&mut self) { + unsafe { imp::PropVariantClear(&mut self.0) }; + } +} + +impl TypeKind for VARIANT { + type TypeKind = ValueType; +} + +impl TypeKind for PROPVARIANT { + type TypeKind = ValueType; +} + +impl std::fmt::Debug for VARIANT { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let mut debug = f.debug_struct("VARIANT"); + debug.field("type", &unsafe { self.0.Anonymous.Anonymous.vt }); + + if let Ok(value) = BSTR::try_from(self) { + debug.field("value", &value); + } + + debug.finish() + } +} + +impl std::fmt::Debug for PROPVARIANT { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let mut debug = f.debug_struct("PROPVARIANT"); + debug.field("type", &unsafe { self.0.Anonymous.Anonymous.vt }); + + if let Ok(value) = BSTR::try_from(self) { + debug.field("value", &value); + } + + debug.finish() + } +} + +impl PartialEq for VARIANT { + fn eq(&self, other: &Self) -> bool { + unsafe { + if self.0.Anonymous.Anonymous.vt != other.0.Anonymous.Anonymous.vt { + return false; + } + let this = PROPVARIANT::try_from(self); + let other = PROPVARIANT::try_from(other); + + if let (Ok(this), Ok(other)) = (this, other) { + this.eq(&other) + } else { + false + } + } + } +} + +impl PartialEq for PROPVARIANT { + fn eq(&self, other: &Self) -> bool { + unsafe { + if self.0.Anonymous.Anonymous.vt != other.0.Anonymous.Anonymous.vt { + return false; + } + + imp::PropVariantCompareEx(&self.0, &other.0, 0, 0) == 0 + } + } +} + +impl Eq for VARIANT {} +impl Eq for PROPVARIANT {} + +impl VARIANT { + pub fn new() -> Self { + unsafe { std::mem::zeroed() } + } + + pub const fn is_empty(&self) -> bool { + unsafe { self.0.Anonymous.Anonymous.vt == imp::VT_EMPTY } + } +} + +impl PROPVARIANT { + pub fn new() -> Self { + unsafe { std::mem::zeroed() } + } + + pub const fn is_empty(&self) -> bool { + unsafe { self.0.Anonymous.Anonymous.vt == imp::VT_EMPTY } + } +} + +impl TryFrom<&VARIANT> for PROPVARIANT { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + unsafe { + let mut value = Self::new(); + HRESULT(imp::VariantToPropVariant(&from.0, &mut value.0)).and_then(|| value) + } + } +} + +impl TryFrom<&PROPVARIANT> for VARIANT { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + unsafe { + let mut value = Self::new(); + HRESULT(imp::PropVariantToVariant(&from.0, &mut value.0)).and_then(|| value) + } + } +} + +// VT_BSTR + +impl From for VARIANT { + fn from(value: BSTR) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { + Anonymous: imp::VARIANT_0_0 { vt: imp::VT_BSTR, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { bstrVal: value.into_raw() } }, + }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: BSTR) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_BSTR, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { bstrVal: value.into_raw() } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for BSTR { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let pv = PROPVARIANT::try_from(from)?; + BSTR::try_from(&pv) + } +} + +impl TryFrom<&PROPVARIANT> for BSTR { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = Self::new(); + HRESULT(unsafe { imp::PropVariantToBSTR(&from.0, &mut value as *mut _ as *mut _) }).and_then(|| value) + } +} + +// VT_BOOL + +impl From for VARIANT { + fn from(value: bool) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { + Anonymous: imp::VARIANT_0_0 { vt: imp::VT_BOOL, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { boolVal: if value { -1 } else { 0 } } }, + }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: bool) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_BOOL, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { boolVal: if value { -1 } else { 0 } } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for bool { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToBoolean(&from.0, &mut value) }).and_then(|| value != 0) + } +} + +impl TryFrom<&PROPVARIANT> for bool { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToBoolean(&from.0, &mut value) }).and_then(|| value != 0) + } +} + +// VT_UI1 + +impl From for VARIANT { + fn from(value: u8) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_UI1, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { bVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: u8) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_UI1, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { bVal: value } }, + }, + }) + } +} + +// VT_I1 + +impl From for VARIANT { + fn from(value: i8) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_I1, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { cVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: i8) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_I1, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { cVal: value } }, + }, + }) + } +} + +// VT_UI2 + +impl From for VARIANT { + fn from(value: u16) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_UI2, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { uiVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: u16) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_UI2, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { uiVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for u16 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToUInt16(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for u16 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToUInt16(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_I2 + +impl From for VARIANT { + fn from(value: i16) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_I2, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { iVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: i16) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_I2, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { iVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for i16 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToInt16(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for i16 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToInt16(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_UI4 + +impl From for VARIANT { + fn from(value: u32) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_UI4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { ulVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: u32) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_UI4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { ulVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for u32 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToUInt32(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for u32 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToUInt32(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_I4 + +impl From for VARIANT { + fn from(value: i32) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_I4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { lVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: i32) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_I4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { lVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for i32 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToInt32(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for i32 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToInt32(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_UI8 + +impl From for VARIANT { + fn from(value: u64) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_UI8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { ullVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: u64) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_UI8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { uhVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for u64 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToUInt64(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for u64 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToUInt64(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_I8 + +impl From for VARIANT { + fn from(value: i64) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_I8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { llVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: i64) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_I8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { hVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for i64 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::VariantToInt64(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for i64 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0; + HRESULT(unsafe { imp::PropVariantToInt64(&from.0, &mut value) }).and_then(|| value) + } +} + +// VT_R4 + +impl From for VARIANT { + fn from(value: f32) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_R4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { fltVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: f32) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_R4, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { fltVal: value } }, + }, + }) + } +} + +// VT_R8 + +impl From for VARIANT { + fn from(value: f64) -> Self { + Self(imp::VARIANT { + Anonymous: imp::VARIANT_0 { Anonymous: imp::VARIANT_0_0 { vt: imp::VT_R8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::VARIANT_0_0_0 { dblVal: value } } }, + }) + } +} + +impl From for PROPVARIANT { + fn from(value: f64) -> Self { + Self(imp::PROPVARIANT { + Anonymous: imp::PROPVARIANT_0 { + Anonymous: imp::PROPVARIANT_0_0 { vt: imp::VT_R8, wReserved1: 0, wReserved2: 0, wReserved3: 0, Anonymous: imp::PROPVARIANT_0_0_0 { dblVal: value } }, + }, + }) + } +} + +impl TryFrom<&VARIANT> for f64 { + type Error = Error; + fn try_from(from: &VARIANT) -> Result { + let mut value = 0.0; + HRESULT(unsafe { imp::VariantToDouble(&from.0, &mut value) }).and_then(|| value) + } +} + +impl TryFrom<&PROPVARIANT> for f64 { + type Error = Error; + fn try_from(from: &PROPVARIANT) -> Result { + let mut value = 0.0; + HRESULT(unsafe { imp::PropVariantToDouble(&from.0, &mut value) }).and_then(|| value) + } +} diff --git a/crates/libs/metadata/src/reader.rs b/crates/libs/metadata/src/reader.rs index b962c68eae..6654988a70 100644 --- a/crates/libs/metadata/src/reader.rs +++ b/crates/libs/metadata/src/reader.rs @@ -19,15 +19,19 @@ pub struct Reader { // The reader needs to store the filter since standalone code generation needs more than just the filtered items // in order to chase dependencies automatically. This is why `Reader::filter` can't just filter everything up front. filter: Filter, + + sys: bool, } impl Reader { pub fn new(files: Vec) -> &'static Self { - Self::filter(files, &[], &[]) + let mut config = BTreeMap::new(); + config.insert("sys", ""); + Self::filter(files, &[], &[], &config) } - pub fn filter(files: Vec, include: &[&str], exclude: &[&str]) -> &'static Self { - let reader: &'static mut Reader = Box::leak(Box::new(Self { items: Default::default(), nested: Default::default(), filter: Filter::new(include, exclude) })); + pub fn filter(files: Vec, include: &[&str], exclude: &[&str], config: &BTreeMap<&str, &str>) -> &'static Self { + let reader: &'static mut Reader = Box::leak(Box::new(Self { items: Default::default(), nested: Default::default(), filter: Filter::new(include, exclude), sys: config.contains_key("sys") })); for mut file in files { file.reader = reader as *mut Reader; @@ -136,6 +140,22 @@ impl Reader { self.nested.get(&type_def).map(|map| map.values().copied()).into_iter().flatten() } + pub fn remap_types(&self) -> impl Iterator + '_ { + if self.sys { + [].iter() + } else { + REMAP_TYPES.iter() + } + } + + pub fn core_types(&self) -> impl Iterator + '_ { + if self.sys { + SYS_CORE_TYPES.iter() + } else { + CORE_TYPES.iter() + } + } + pub fn type_from_ref(&self, code: TypeDefOrRef, enclosing: Option, generics: &[Type]) -> Type { if let TypeDefOrRef::TypeSpec(def) = code { let mut blob = def.blob(0); @@ -144,17 +164,15 @@ impl Reader { let mut full_name = code.type_name(); - // TODO: remove this - for (known_name, kind) in CORE_TYPES { - if full_name == known_name { - return kind; + for (known_name, kind) in self.core_types() { + if full_name == *known_name { + return kind.clone(); } } - // TODO: remove this - for (from, to) in REMAP_TYPES { - if full_name == from { - full_name = to; + for (from, to) in self.remap_types() { + if full_name == *from { + full_name = *to; break; } } @@ -249,7 +267,8 @@ impl Reader { } // TODO: this should be in riddle's Rust generator if at all - perhaps as convertible types rather than remapped types since there's already some precedent for that. -pub const REMAP_TYPES: [(TypeName, TypeName); 2] = [(TypeName::D2D_MATRIX_3X2_F, TypeName::Matrix3x2), (TypeName::D3DMATRIX, TypeName::Matrix4x4)]; +const REMAP_TYPES: [(TypeName, TypeName); 2] = [(TypeName::D2D_MATRIX_3X2_F, TypeName::Matrix3x2), (TypeName::D3DMATRIX, TypeName::Matrix4x4)]; // TODO: get rid of at least the second tuple if not the whole thing. -pub const CORE_TYPES: [(TypeName, Type); 11] = [(TypeName::GUID, Type::GUID), (TypeName::IUnknown, Type::IUnknown), (TypeName::HResult, Type::HRESULT), (TypeName::HRESULT, Type::HRESULT), (TypeName::HSTRING, Type::String), (TypeName::BSTR, Type::BSTR), (TypeName::IInspectable, Type::IInspectable), (TypeName::PSTR, Type::PSTR), (TypeName::PWSTR, Type::PWSTR), (TypeName::Type, Type::Type), (TypeName::CHAR, Type::I8)]; +const CORE_TYPES: [(TypeName, Type); 13] = [(TypeName::GUID, Type::GUID), (TypeName::IUnknown, Type::IUnknown), (TypeName::HResult, Type::HRESULT), (TypeName::HRESULT, Type::HRESULT), (TypeName::HSTRING, Type::String), (TypeName::BSTR, Type::BSTR), (TypeName::IInspectable, Type::IInspectable), (TypeName::PSTR, Type::PSTR), (TypeName::PWSTR, Type::PWSTR), (TypeName::Type, Type::Type), (TypeName::CHAR, Type::I8), (TypeName::VARIANT, Type::VARIANT), (TypeName::PROPVARIANT, Type::PROPVARIANT)]; +const SYS_CORE_TYPES: [(TypeName, Type); 11] = [(TypeName::GUID, Type::GUID), (TypeName::IUnknown, Type::IUnknown), (TypeName::HResult, Type::HRESULT), (TypeName::HRESULT, Type::HRESULT), (TypeName::HSTRING, Type::String), (TypeName::BSTR, Type::BSTR), (TypeName::IInspectable, Type::IInspectable), (TypeName::PSTR, Type::PSTR), (TypeName::PWSTR, Type::PWSTR), (TypeName::Type, Type::Type), (TypeName::CHAR, Type::I8)]; diff --git a/crates/libs/metadata/src/type.rs b/crates/libs/metadata/src/type.rs index 5c2c24eb61..de7776d846 100644 --- a/crates/libs/metadata/src/type.rs +++ b/crates/libs/metadata/src/type.rs @@ -49,6 +49,8 @@ pub enum Type { PCSTR, PCWSTR, BSTR, + VARIANT, + PROPVARIANT, } impl Type { diff --git a/crates/libs/metadata/src/type_name.rs b/crates/libs/metadata/src/type_name.rs index 431e0f3f97..de0fce9258 100644 --- a/crates/libs/metadata/src/type_name.rs +++ b/crates/libs/metadata/src/type_name.rs @@ -47,6 +47,9 @@ impl TypeName { pub const IRestrictedErrorInfo: Self = Self::from_const("Windows.Win32.System.WinRT", "IRestrictedErrorInfo"); pub const IDispatch: Self = Self::from_const("Windows.Win32.System.Com", "IDispatch"); + pub const VARIANT: Self = Self::from_const("Windows.Win32.System.Variant", "VARIANT"); + pub const PROPVARIANT: Self = Self::from_const("Windows.Win32.System.Com.StructuredStorage", "PROPVARIANT"); + const fn from_const(namespace: &'static str, name: &'static str) -> Self { Self { namespace, name } } diff --git a/crates/libs/sys/src/Windows/Wdk/Graphics/Direct3D/mod.rs b/crates/libs/sys/src/Windows/Wdk/Graphics/Direct3D/mod.rs index 83b53195da..3881012d26 100644 --- a/crates/libs/sys/src/Windows/Wdk/Graphics/Direct3D/mod.rs +++ b/crates/libs/sys/src/Windows/Wdk/Graphics/Direct3D/mod.rs @@ -4502,15 +4502,15 @@ impl ::core::clone::Clone for D3DHAL_DP2LINESTRIP { } } #[repr(C)] -#[doc = "Required features: `\"Foundation_Numerics\"`, `\"Win32_Graphics_Direct3D9\"`"] -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[doc = "Required features: `\"Win32_Graphics_Direct3D\"`, `\"Win32_Graphics_Direct3D9\"`"] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] pub struct D3DHAL_DP2MULTIPLYTRANSFORM { pub xfrmType: super::super::super::Win32::Graphics::Direct3D9::D3DTRANSFORMSTATETYPE, - pub matrix: super::super::super::Foundation::Numerics::Matrix4x4, + pub matrix: super::super::super::Win32::Graphics::Direct3D::D3DMATRIX, } -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::marker::Copy for D3DHAL_DP2MULTIPLYTRANSFORM {} -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::clone::Clone for D3DHAL_DP2MULTIPLYTRANSFORM { fn clone(&self) -> Self { *self @@ -4761,15 +4761,15 @@ impl ::core::clone::Clone for D3DHAL_DP2SETTEXLOD { } } #[repr(C)] -#[doc = "Required features: `\"Foundation_Numerics\"`, `\"Win32_Graphics_Direct3D9\"`"] -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[doc = "Required features: `\"Win32_Graphics_Direct3D\"`, `\"Win32_Graphics_Direct3D9\"`"] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] pub struct D3DHAL_DP2SETTRANSFORM { pub xfrmType: super::super::super::Win32::Graphics::Direct3D9::D3DTRANSFORMSTATETYPE, - pub matrix: super::super::super::Foundation::Numerics::Matrix4x4, + pub matrix: super::super::super::Win32::Graphics::Direct3D::D3DMATRIX, } -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::marker::Copy for D3DHAL_DP2SETTRANSFORM {} -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::clone::Clone for D3DHAL_DP2SETTRANSFORM { fn clone(&self) -> Self { *self @@ -13323,15 +13323,15 @@ impl ::core::clone::Clone for D3DNTHAL_DP2LINESTRIP { } } #[repr(C)] -#[doc = "Required features: `\"Foundation_Numerics\"`, `\"Win32_Graphics_Direct3D9\"`"] -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[doc = "Required features: `\"Win32_Graphics_Direct3D\"`, `\"Win32_Graphics_Direct3D9\"`"] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] pub struct D3DNTHAL_DP2MULTIPLYTRANSFORM { pub xfrmType: super::super::super::Win32::Graphics::Direct3D9::D3DTRANSFORMSTATETYPE, - pub matrix: super::super::super::Foundation::Numerics::Matrix4x4, + pub matrix: super::super::super::Win32::Graphics::Direct3D::D3DMATRIX, } -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::marker::Copy for D3DNTHAL_DP2MULTIPLYTRANSFORM {} -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::clone::Clone for D3DNTHAL_DP2MULTIPLYTRANSFORM { fn clone(&self) -> Self { *self @@ -13593,15 +13593,15 @@ impl ::core::clone::Clone for D3DNTHAL_DP2SETTEXLOD { } } #[repr(C)] -#[doc = "Required features: `\"Foundation_Numerics\"`, `\"Win32_Graphics_Direct3D9\"`"] -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[doc = "Required features: `\"Win32_Graphics_Direct3D\"`, `\"Win32_Graphics_Direct3D9\"`"] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] pub struct D3DNTHAL_DP2SETTRANSFORM { pub xfrmType: super::super::super::Win32::Graphics::Direct3D9::D3DTRANSFORMSTATETYPE, - pub matrix: super::super::super::Foundation::Numerics::Matrix4x4, + pub matrix: super::super::super::Win32::Graphics::Direct3D::D3DMATRIX, } -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::marker::Copy for D3DNTHAL_DP2SETTRANSFORM {} -#[cfg(all(feature = "Foundation_Numerics", feature = "Win32_Graphics_Direct3D9"))] +#[cfg(all(feature = "Win32_Graphics_Direct3D", feature = "Win32_Graphics_Direct3D9"))] impl ::core::clone::Clone for D3DNTHAL_DP2SETTRANSFORM { fn clone(&self) -> Self { *self diff --git a/crates/libs/windows/src/Windows/Win32/Data/HtmlHelp/mod.rs b/crates/libs/windows/src/Windows/Win32/Data/HtmlHelp/mod.rs index ce081cf944..44330d67e1 100644 --- a/crates/libs/windows/src/Windows/Win32/Data/HtmlHelp/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Data/HtmlHelp/mod.rs @@ -1080,23 +1080,29 @@ impl ::core::default::Default for HH_FTS_QUERY { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct HH_GLOBAL_PROPERTY { pub id: HH_GPROPID, - pub var: super::super::System::Variant::VARIANT, + pub var: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for HH_GLOBAL_PROPERTY { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for HH_GLOBAL_PROPERTY { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("HH_GLOBAL_PROPERTY").field("id", &self.id).field("var", &self.var).finish() + } +} impl ::windows_core::TypeKind for HH_GLOBAL_PROPERTY { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for HH_GLOBAL_PROPERTY { + fn eq(&self, other: &Self) -> bool { + self.id == other.id && self.var == other.var + } +} +impl ::core::cmp::Eq for HH_GLOBAL_PROPERTY {} impl ::core::default::Default for HH_GLOBAL_PROPERTY { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/impl.rs b/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/impl.rs index c88bbe9efa..3299abdea2 100644 --- a/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/impl.rs @@ -1,21 +1,21 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXAttributes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn addAttribute(&self, struri: &::windows_core::BSTR, strlocalname: &::windows_core::BSTR, strqname: &::windows_core::BSTR, strtype: &::windows_core::BSTR, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn addAttributeFromIndex(&self, varatts: &super::super::super::System::Variant::VARIANT, nindex: i32) -> ::windows_core::Result<()>; + fn addAttributeFromIndex(&self, varatts: &::windows_core::VARIANT, nindex: i32) -> ::windows_core::Result<()>; fn clear(&self) -> ::windows_core::Result<()>; fn removeAttribute(&self, nindex: i32) -> ::windows_core::Result<()>; fn setAttribute(&self, nindex: i32, struri: &::windows_core::BSTR, strlocalname: &::windows_core::BSTR, strqname: &::windows_core::BSTR, strtype: &::windows_core::BSTR, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn setAttributes(&self, varatts: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn setAttributes(&self, varatts: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn setLocalName(&self, nindex: i32, strlocalname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn setQName(&self, nindex: i32, strqname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn setType(&self, nindex: i32, strtype: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn setURI(&self, nindex: i32, struri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn setValue(&self, nindex: i32, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXAttributes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXAttributes_Vtbl { pub const fn new, Impl: IMXAttributes_Impl, const OFFSET: isize>() -> IMXAttributes_Vtbl { unsafe extern "system" fn addAttribute, Impl: IMXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, struri: ::std::mem::MaybeUninit<::windows_core::BSTR>, strlocalname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strqname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, strvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -23,7 +23,7 @@ impl IMXAttributes_Vtbl { let this = (*this).get_impl(); this.addAttribute(::core::mem::transmute(&struri), ::core::mem::transmute(&strlocalname), ::core::mem::transmute(&strqname), ::core::mem::transmute(&strtype), ::core::mem::transmute(&strvalue)).into() } - unsafe extern "system" fn addAttributeFromIndex, Impl: IMXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varatts: super::super::super::System::Variant::VARIANT, nindex: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn addAttributeFromIndex, Impl: IMXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varatts: ::std::mem::MaybeUninit<::windows_core::VARIANT>, nindex: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.addAttributeFromIndex(::core::mem::transmute(&varatts), ::core::mem::transmute_copy(&nindex)).into() @@ -43,7 +43,7 @@ impl IMXAttributes_Vtbl { let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute_copy(&nindex), ::core::mem::transmute(&struri), ::core::mem::transmute(&strlocalname), ::core::mem::transmute(&strqname), ::core::mem::transmute(&strtype), ::core::mem::transmute(&strvalue)).into() } - unsafe extern "system" fn setAttributes, Impl: IMXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varatts: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttributes, Impl: IMXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varatts: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttributes(::core::mem::transmute(&varatts)).into() @@ -185,16 +185,16 @@ impl IMXNamespaceManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXNamespacePrefixes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_item(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn length(&self) -> ::windows_core::Result; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXNamespacePrefixes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXNamespacePrefixes_Vtbl { pub const fn new, Impl: IMXNamespacePrefixes_Impl, const OFFSET: isize>() -> IMXNamespacePrefixes_Vtbl { unsafe extern "system" fn get_item, Impl: IMXNamespacePrefixes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, prefix: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -241,16 +241,16 @@ impl IMXNamespacePrefixes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXReaderControl_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn abort(&self) -> ::windows_core::Result<()>; fn resume(&self) -> ::windows_core::Result<()>; fn suspend(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXReaderControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXReaderControl_Vtbl { pub const fn new, Impl: IMXReaderControl_Impl, const OFFSET: isize>() -> IMXReaderControl_Vtbl { unsafe extern "system" fn abort, Impl: IMXReaderControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -279,14 +279,14 @@ impl IMXReaderControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXSchemaDeclHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn schemaElementDecl(&self, oschemaelement: ::core::option::Option<&ISchemaElement>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXSchemaDeclHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXSchemaDeclHandler_Vtbl { pub const fn new, Impl: IMXSchemaDeclHandler_Impl, const OFFSET: isize>() -> IMXSchemaDeclHandler_Vtbl { unsafe extern "system" fn schemaElementDecl, Impl: IMXSchemaDeclHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, oschemaelement: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -303,11 +303,11 @@ impl IMXSchemaDeclHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXWriter_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn Setoutput(&self, vardestination: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn output(&self) -> ::windows_core::Result; + fn Setoutput(&self, vardestination: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn output(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Setencoding(&self, strencoding: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn encoding(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetbyteOrderMark(&self, fwritebyteordermark: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -324,17 +324,17 @@ pub trait IMXWriter_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn disableOutputEscaping(&self) -> ::windows_core::Result; fn flush(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXWriter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXWriter_Vtbl { pub const fn new, Impl: IMXWriter_Impl, const OFFSET: isize>() -> IMXWriter_Vtbl { - unsafe extern "system" fn Setoutput, Impl: IMXWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestination: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setoutput, Impl: IMXWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestination: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setoutput(::core::mem::transmute(&vardestination)).into() } - unsafe extern "system" fn output, Impl: IMXWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestination: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn output, Impl: IMXWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestination: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.output() { @@ -487,13 +487,13 @@ impl IMXWriter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMXXMLFilter_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn getFeature(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; fn putFeature(&self, strname: &::windows_core::BSTR, fvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn getProperty(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; - fn putProperty(&self, strname: &::windows_core::BSTR, varvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getProperty(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn putProperty(&self, strname: &::windows_core::BSTR, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn entityResolver(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn putref_entityResolver(&self, oresolver: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn contentHandler(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -503,9 +503,9 @@ pub trait IMXXMLFilter_Impl: Sized + super::super::super::System::Com::IDispatch fn errorHandler(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn putref_errorHandler(&self, ohandler: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMXXMLFilter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMXXMLFilter_Vtbl { pub const fn new, Impl: IMXXMLFilter_Impl, const OFFSET: isize>() -> IMXXMLFilter_Vtbl { unsafe extern "system" fn getFeature, Impl: IMXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -524,7 +524,7 @@ impl IMXXMLFilter_Vtbl { let this = (*this).get_impl(); this.putFeature(::core::mem::transmute(&strname), ::core::mem::transmute_copy(&fvalue)).into() } - unsafe extern "system" fn getProperty, Impl: IMXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getProperty, Impl: IMXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getProperty(::core::mem::transmute(&strname)) { @@ -535,7 +535,7 @@ impl IMXXMLFilter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn putProperty, Impl: IMXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn putProperty, Impl: IMXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.putProperty(::core::mem::transmute(&strname), ::core::mem::transmute(&varvalue)).into() @@ -904,17 +904,13 @@ impl ISAXDeclHandler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISAXEntityResolver_Impl: Sized { - fn resolveEntity(&self, pwchpublicid: &::windows_core::PCWSTR, pwchsystemid: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn resolveEntity(&self, pwchpublicid: &::windows_core::PCWSTR, pwchsystemid: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISAXEntityResolver {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISAXEntityResolver_Vtbl { pub const fn new, Impl: ISAXEntityResolver_Impl, const OFFSET: isize>() -> ISAXEntityResolver_Vtbl { - unsafe extern "system" fn resolveEntity, Impl: ISAXEntityResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchpublicid: ::windows_core::PCWSTR, pwchsystemid: ::windows_core::PCWSTR, pvarinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn resolveEntity, Impl: ISAXEntityResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchpublicid: ::windows_core::PCWSTR, pwchsystemid: ::windows_core::PCWSTR, pvarinput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.resolveEntity(::core::mem::transmute(&pwchpublicid), ::core::mem::transmute(&pwchsystemid)) { @@ -1092,15 +1088,11 @@ impl ISAXLocator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISAXXMLFilter_Impl: Sized + ISAXXMLReader_Impl { fn getParent(&self) -> ::windows_core::Result; fn putParent(&self, preader: ::core::option::Option<&ISAXXMLReader>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISAXXMLFilter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISAXXMLFilter_Vtbl { pub const fn new, Impl: ISAXXMLFilter_Impl, const OFFSET: isize>() -> ISAXXMLFilter_Vtbl { unsafe extern "system" fn getParent, Impl: ISAXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppreader: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1129,13 +1121,11 @@ impl ISAXXMLFilter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISAXXMLReader_Impl: Sized { fn getFeature(&self, pwchname: &::windows_core::PCWSTR) -> ::windows_core::Result; fn putFeature(&self, pwchname: &::windows_core::PCWSTR, vfvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn getProperty(&self, pwchname: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn putProperty(&self, pwchname: &::windows_core::PCWSTR, varvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getProperty(&self, pwchname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn putProperty(&self, pwchname: &::windows_core::PCWSTR, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn getEntityResolver(&self) -> ::windows_core::Result; fn putEntityResolver(&self, presolver: ::core::option::Option<&ISAXEntityResolver>) -> ::windows_core::Result<()>; fn getContentHandler(&self) -> ::windows_core::Result; @@ -1148,12 +1138,10 @@ pub trait ISAXXMLReader_Impl: Sized { fn putBaseURL(&self, pwchbaseurl: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn getSecureBaseURL(&self) -> ::windows_core::Result<*mut u16>; fn putSecureBaseURL(&self, pwchsecurebaseurl: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn parse(&self, varinput: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn parse(&self, varinput: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn parseURL(&self, pwchurl: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISAXXMLReader {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISAXXMLReader_Vtbl { pub const fn new, Impl: ISAXXMLReader_Impl, const OFFSET: isize>() -> ISAXXMLReader_Vtbl { unsafe extern "system" fn getFeature, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvfvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1172,7 +1160,7 @@ impl ISAXXMLReader_Vtbl { let this = (*this).get_impl(); this.putFeature(::core::mem::transmute(&pwchname), ::core::mem::transmute_copy(&vfvalue)).into() } - unsafe extern "system" fn getProperty, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getProperty, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getProperty(::core::mem::transmute(&pwchname)) { @@ -1183,7 +1171,7 @@ impl ISAXXMLReader_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn putProperty, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn putProperty, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.putProperty(::core::mem::transmute(&pwchname), ::core::mem::transmute(&varvalue)).into() @@ -1284,7 +1272,7 @@ impl ISAXXMLReader_Vtbl { let this = (*this).get_impl(); this.putSecureBaseURL(::core::mem::transmute(&pwchsecurebaseurl)).into() } - unsafe extern "system" fn parse, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn parse, Impl: ISAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinput: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.parse(::core::mem::transmute(&varinput)).into() @@ -1320,8 +1308,8 @@ impl ISAXXMLReader_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchema_Impl: Sized + ISchemaItem_Impl { fn targetNamespace(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn version(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1333,9 +1321,9 @@ pub trait ISchema_Impl: Sized + ISchemaItem_Impl { fn notations(&self) -> ::windows_core::Result; fn schemaLocations(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchema {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchema_Vtbl { pub const fn new, Impl: ISchema_Impl, const OFFSET: isize>() -> ISchema_Vtbl { unsafe extern "system" fn targetNamespace, Impl: ISchema_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetnamespace: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1454,15 +1442,15 @@ impl ISchema_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaAny_Impl: Sized + ISchemaParticle_Impl { fn namespaces(&self) -> ::windows_core::Result; fn processContents(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaAny {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaAny_Vtbl { pub const fn new, Impl: ISchemaAny_Impl, const OFFSET: isize>() -> ISchemaAny_Vtbl { unsafe extern "system" fn namespaces, Impl: ISchemaAny_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespaces: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1497,8 +1485,8 @@ impl ISchemaAny_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaAttribute_Impl: Sized + ISchemaItem_Impl { fn r#type(&self) -> ::windows_core::Result; fn scope(&self) -> ::windows_core::Result; @@ -1507,9 +1495,9 @@ pub trait ISchemaAttribute_Impl: Sized + ISchemaItem_Impl { fn r#use(&self) -> ::windows_core::Result; fn isReference(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaAttribute {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaAttribute_Vtbl { pub const fn new, Impl: ISchemaAttribute_Impl, const OFFSET: isize>() -> ISchemaAttribute_Vtbl { unsafe extern "system" fn r#type, Impl: ISchemaAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1592,15 +1580,15 @@ impl ISchemaAttribute_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaAttributeGroup_Impl: Sized + ISchemaItem_Impl { fn anyAttribute(&self) -> ::windows_core::Result; fn attributes(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaAttributeGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaAttributeGroup_Vtbl { pub const fn new, Impl: ISchemaAttributeGroup_Impl, const OFFSET: isize>() -> ISchemaAttributeGroup_Vtbl { unsafe extern "system" fn anyAttribute, Impl: ISchemaAttributeGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, anyattribute: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1635,8 +1623,8 @@ impl ISchemaAttributeGroup_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaComplexType_Impl: Sized + ISchemaType_Impl { fn isAbstract(&self) -> ::windows_core::Result; fn anyAttribute(&self) -> ::windows_core::Result; @@ -1645,9 +1633,9 @@ pub trait ISchemaComplexType_Impl: Sized + ISchemaType_Impl { fn contentModel(&self) -> ::windows_core::Result; fn prohibitedSubstitutions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaComplexType {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaComplexType_Vtbl { pub const fn new, Impl: ISchemaComplexType_Impl, const OFFSET: isize>() -> ISchemaComplexType_Vtbl { unsafe extern "system" fn isAbstract, Impl: ISchemaComplexType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#abstract: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1730,8 +1718,8 @@ impl ISchemaComplexType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaElement_Impl: Sized + ISchemaParticle_Impl { fn r#type(&self) -> ::windows_core::Result; fn scope(&self) -> ::windows_core::Result; @@ -1745,9 +1733,9 @@ pub trait ISchemaElement_Impl: Sized + ISchemaParticle_Impl { fn isAbstract(&self) -> ::windows_core::Result; fn isReference(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaElement_Vtbl { pub const fn new, Impl: ISchemaElement_Impl, const OFFSET: isize>() -> ISchemaElement_Vtbl { unsafe extern "system" fn r#type, Impl: ISchemaElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1890,16 +1878,16 @@ impl ISchemaElement_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaIdentityConstraint_Impl: Sized + ISchemaItem_Impl { fn selector(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn fields(&self) -> ::windows_core::Result; fn referencedKey(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaIdentityConstraint {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaIdentityConstraint_Vtbl { pub const fn new, Impl: ISchemaIdentityConstraint_Impl, const OFFSET: isize>() -> ISchemaIdentityConstraint_Vtbl { unsafe extern "system" fn selector, Impl: ISchemaIdentityConstraint_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, selector: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1946,8 +1934,8 @@ impl ISchemaIdentityConstraint_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaItem_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn namespaceURI(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1957,9 +1945,9 @@ pub trait ISchemaItem_Impl: Sized + super::super::super::System::Com::IDispatch_ fn unhandledAttributes(&self) -> ::windows_core::Result; fn writeAnnotation(&self, annotationsink: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaItem_Vtbl { pub const fn new, Impl: ISchemaItem_Impl, const OFFSET: isize>() -> ISchemaItem_Vtbl { unsafe extern "system" fn name, Impl: ISchemaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2054,8 +2042,8 @@ impl ISchemaItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaItemCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_item(&self, index: i32) -> ::windows_core::Result; fn itemByName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; @@ -2063,9 +2051,9 @@ pub trait ISchemaItemCollection_Impl: Sized + super::super::super::System::Com:: fn length(&self) -> ::windows_core::Result; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaItemCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaItemCollection_Vtbl { pub const fn new, Impl: ISchemaItemCollection_Impl, const OFFSET: isize>() -> ISchemaItemCollection_Vtbl { unsafe extern "system" fn get_item, Impl: ISchemaItemCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, item: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2136,14 +2124,14 @@ impl ISchemaItemCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaModelGroup_Impl: Sized + ISchemaParticle_Impl { fn particles(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaModelGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaModelGroup_Vtbl { pub const fn new, Impl: ISchemaModelGroup_Impl, const OFFSET: isize>() -> ISchemaModelGroup_Vtbl { unsafe extern "system" fn particles, Impl: ISchemaModelGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, particles: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2163,15 +2151,15 @@ impl ISchemaModelGroup_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaNotation_Impl: Sized + ISchemaItem_Impl { fn systemIdentifier(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn publicIdentifier(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaNotation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaNotation_Vtbl { pub const fn new, Impl: ISchemaNotation_Impl, const OFFSET: isize>() -> ISchemaNotation_Vtbl { unsafe extern "system" fn systemIdentifier, Impl: ISchemaNotation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2206,18 +2194,18 @@ impl ISchemaNotation_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaParticle_Impl: Sized + ISchemaItem_Impl { - fn minOccurs(&self) -> ::windows_core::Result; - fn maxOccurs(&self) -> ::windows_core::Result; + fn minOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn maxOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaParticle {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaParticle_Vtbl { pub const fn new, Impl: ISchemaParticle_Impl, const OFFSET: isize>() -> ISchemaParticle_Vtbl { - unsafe extern "system" fn minOccurs, Impl: ISchemaParticle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minoccurs: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn minOccurs, Impl: ISchemaParticle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minoccurs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.minOccurs() { @@ -2228,7 +2216,7 @@ impl ISchemaParticle_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn maxOccurs, Impl: ISchemaParticle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, maxoccurs: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn maxOccurs, Impl: ISchemaParticle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, maxoccurs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.maxOccurs() { @@ -2249,16 +2237,16 @@ impl ISchemaParticle_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaStringCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_item(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn length(&self) -> ::windows_core::Result; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaStringCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaStringCollection_Vtbl { pub const fn new, Impl: ISchemaStringCollection_Impl, const OFFSET: isize>() -> ISchemaStringCollection_Vtbl { unsafe extern "system" fn get_item, Impl: ISchemaStringCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, bstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2305,8 +2293,8 @@ impl ISchemaStringCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchemaType_Impl: Sized + ISchemaItem_Impl { fn baseTypes(&self) -> ::windows_core::Result; fn r#final(&self) -> ::windows_core::Result; @@ -2317,18 +2305,18 @@ pub trait ISchemaType_Impl: Sized + ISchemaItem_Impl { fn minInclusive(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn maxExclusive(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn maxInclusive(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn totalDigits(&self) -> ::windows_core::Result; - fn fractionDigits(&self) -> ::windows_core::Result; - fn length(&self) -> ::windows_core::Result; - fn minLength(&self) -> ::windows_core::Result; - fn maxLength(&self) -> ::windows_core::Result; + fn totalDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn fractionDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn length(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn minLength(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn maxLength(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn enumeration(&self) -> ::windows_core::Result; fn whitespace(&self) -> ::windows_core::Result; fn patterns(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchemaType {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchemaType_Vtbl { pub const fn new, Impl: ISchemaType_Impl, const OFFSET: isize>() -> ISchemaType_Vtbl { unsafe extern "system" fn baseTypes, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, basetypes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2430,7 +2418,7 @@ impl ISchemaType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn totalDigits, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, totaldigits: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn totalDigits, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, totaldigits: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.totalDigits() { @@ -2441,7 +2429,7 @@ impl ISchemaType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn fractionDigits, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fractiondigits: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn fractionDigits, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fractiondigits: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.fractionDigits() { @@ -2452,7 +2440,7 @@ impl ISchemaType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn length, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, length: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn length, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, length: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.length() { @@ -2463,7 +2451,7 @@ impl ISchemaType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn minLength, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minlength: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn minLength, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minlength: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.minLength() { @@ -2474,7 +2462,7 @@ impl ISchemaType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn maxLength, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, maxlength: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn maxLength, Impl: ISchemaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, maxlength: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.maxLength() { @@ -2543,17 +2531,17 @@ impl ISchemaType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IServerXMLHTTPRequest_Impl: Sized + IXMLHTTPRequest_Impl { fn setTimeouts(&self, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::Result<()>; - fn waitForResponse(&self, timeoutinseconds: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result; - fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn waitForResponse(&self, timeoutinseconds: &::windows_core::VARIANT) -> ::windows_core::Result; + fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IServerXMLHTTPRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IServerXMLHTTPRequest_Vtbl { pub const fn new, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>() -> IServerXMLHTTPRequest_Vtbl { unsafe extern "system" fn setTimeouts, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::HRESULT { @@ -2561,7 +2549,7 @@ impl IServerXMLHTTPRequest_Vtbl { let this = (*this).get_impl(); this.setTimeouts(::core::mem::transmute_copy(&resolvetimeout), ::core::mem::transmute_copy(&connecttimeout), ::core::mem::transmute_copy(&sendtimeout), ::core::mem::transmute_copy(&receivetimeout)).into() } - unsafe extern "system" fn waitForResponse, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, timeoutinseconds: super::super::super::System::Variant::VARIANT, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn waitForResponse, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, timeoutinseconds: ::std::mem::MaybeUninit<::windows_core::VARIANT>, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.waitForResponse(::core::mem::transmute(&timeoutinseconds)) { @@ -2572,7 +2560,7 @@ impl IServerXMLHTTPRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getOption, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getOption, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getOption(::core::mem::transmute_copy(&option)) { @@ -2583,7 +2571,7 @@ impl IServerXMLHTTPRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setOption, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setOption, Impl: IServerXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setOption(::core::mem::transmute_copy(&option), ::core::mem::transmute(&value)).into() @@ -2600,18 +2588,18 @@ impl IServerXMLHTTPRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IServerXMLHTTPRequest2_Impl: Sized + IServerXMLHTTPRequest_Impl { - fn setProxy(&self, proxysetting: SXH_PROXY_SETTING, varproxyserver: &super::super::super::System::Variant::VARIANT, varbypasslist: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn setProxy(&self, proxysetting: SXH_PROXY_SETTING, varproxyserver: &::windows_core::VARIANT, varbypasslist: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn setProxyCredentials(&self, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IServerXMLHTTPRequest2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IServerXMLHTTPRequest2_Vtbl { pub const fn new, Impl: IServerXMLHTTPRequest2_Impl, const OFFSET: isize>() -> IServerXMLHTTPRequest2_Vtbl { - unsafe extern "system" fn setProxy, Impl: IServerXMLHTTPRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proxysetting: SXH_PROXY_SETTING, varproxyserver: super::super::super::System::Variant::VARIANT, varbypasslist: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setProxy, Impl: IServerXMLHTTPRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proxysetting: SXH_PROXY_SETTING, varproxyserver: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varbypasslist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setProxy(::core::mem::transmute_copy(&proxysetting), ::core::mem::transmute(&varproxyserver), ::core::mem::transmute(&varbypasslist)).into() @@ -2631,8 +2619,8 @@ impl IServerXMLHTTPRequest2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBMXNamespaceManager_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn SetallowOverride(&self, foverride: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn allowOverride(&self) -> ::windows_core::Result; @@ -2643,12 +2631,12 @@ pub trait IVBMXNamespaceManager_Impl: Sized + super::super::super::System::Com:: fn declarePrefix(&self, prefix: &::windows_core::BSTR, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn getDeclaredPrefixes(&self) -> ::windows_core::Result; fn getPrefixes(&self, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; - fn getURI(&self, prefix: &::windows_core::BSTR) -> ::windows_core::Result; - fn getURIFromNode(&self, strprefix: &::windows_core::BSTR, contextnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; + fn getURI(&self, prefix: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn getURIFromNode(&self, strprefix: &::windows_core::BSTR, contextnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBMXNamespaceManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBMXNamespaceManager_Vtbl { pub const fn new, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>() -> IVBMXNamespaceManager_Vtbl { unsafe extern "system" fn SetallowOverride, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, foverride: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2714,7 +2702,7 @@ impl IVBMXNamespaceManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getURI, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, prefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, uri: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getURI, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, prefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, uri: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getURI(::core::mem::transmute(&prefix)) { @@ -2725,7 +2713,7 @@ impl IVBMXNamespaceManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getURIFromNode, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strprefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, contextnode: *mut ::core::ffi::c_void, uri: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getURIFromNode, Impl: IVBMXNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strprefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, contextnode: *mut ::core::ffi::c_void, uri: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getURIFromNode(::core::mem::transmute(&strprefix), ::windows_core::from_raw_borrowed(&contextnode)) { @@ -2755,8 +2743,8 @@ impl IVBMXNamespaceManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXAttributes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn length(&self) -> ::windows_core::Result; fn getURI(&self, nindex: i32) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2771,9 +2759,9 @@ pub trait IVBSAXAttributes_Impl: Sized + super::super::super::System::Com::IDisp fn getValueFromName(&self, struri: &::windows_core::BSTR, strlocalname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn getValueFromQName(&self, strqname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXAttributes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXAttributes_Vtbl { pub const fn new, Impl: IVBSAXAttributes_Impl, const OFFSET: isize>() -> IVBSAXAttributes_Vtbl { unsafe extern "system" fn length, Impl: IVBSAXAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nlength: *mut i32) -> ::windows_core::HRESULT { @@ -2928,8 +2916,8 @@ impl IVBSAXAttributes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXContentHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn putref_documentLocator(&self, olocator: ::core::option::Option<&IVBSAXLocator>) -> ::windows_core::Result<()>; fn startDocument(&self) -> ::windows_core::Result<()>; @@ -2943,9 +2931,9 @@ pub trait IVBSAXContentHandler_Impl: Sized + super::super::super::System::Com::I fn processingInstruction(&self, strtarget: *mut ::windows_core::BSTR, strdata: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn skippedEntity(&self, strname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXContentHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXContentHandler_Vtbl { pub const fn new, Impl: IVBSAXContentHandler_Impl, const OFFSET: isize>() -> IVBSAXContentHandler_Vtbl { unsafe extern "system" fn putref_documentLocator, Impl: IVBSAXContentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, olocator: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3022,15 +3010,15 @@ impl IVBSAXContentHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXDTDHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn notationDecl(&self, strname: *mut ::windows_core::BSTR, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn unparsedEntityDecl(&self, strname: *mut ::windows_core::BSTR, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR, strnotationname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXDTDHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXDTDHandler_Vtbl { pub const fn new, Impl: IVBSAXDTDHandler_Impl, const OFFSET: isize>() -> IVBSAXDTDHandler_Vtbl { unsafe extern "system" fn notationDecl, Impl: IVBSAXDTDHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3053,17 +3041,17 @@ impl IVBSAXDTDHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXDeclHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn elementDecl(&self, strname: *mut ::windows_core::BSTR, strmodel: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn attributeDecl(&self, strelementname: *mut ::windows_core::BSTR, strattributename: *mut ::windows_core::BSTR, strtype: *mut ::windows_core::BSTR, strvaluedefault: *mut ::windows_core::BSTR, strvalue: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn internalEntityDecl(&self, strname: *mut ::windows_core::BSTR, strvalue: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn externalEntityDecl(&self, strname: *mut ::windows_core::BSTR, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXDeclHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXDeclHandler_Vtbl { pub const fn new, Impl: IVBSAXDeclHandler_Impl, const OFFSET: isize>() -> IVBSAXDeclHandler_Vtbl { unsafe extern "system" fn elementDecl, Impl: IVBSAXDeclHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strmodel: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3098,17 +3086,17 @@ impl IVBSAXDeclHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXEntityResolver_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn resolveEntity(&self, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR, varinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn resolveEntity(&self, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR, varinput: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXEntityResolver {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXEntityResolver_Vtbl { pub const fn new, Impl: IVBSAXEntityResolver_Impl, const OFFSET: isize>() -> IVBSAXEntityResolver_Vtbl { - unsafe extern "system" fn resolveEntity, Impl: IVBSAXEntityResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn resolveEntity, Impl: IVBSAXEntityResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varinput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.resolveEntity(::core::mem::transmute_copy(&strpublicid), ::core::mem::transmute_copy(&strsystemid), ::core::mem::transmute_copy(&varinput)).into() @@ -3122,16 +3110,16 @@ impl IVBSAXEntityResolver_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXErrorHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn error(&self, olocator: ::core::option::Option<&IVBSAXLocator>, strerrormessage: *mut ::windows_core::BSTR, nerrorcode: i32) -> ::windows_core::Result<()>; fn fatalError(&self, olocator: ::core::option::Option<&IVBSAXLocator>, strerrormessage: *mut ::windows_core::BSTR, nerrorcode: i32) -> ::windows_core::Result<()>; fn ignorableWarning(&self, olocator: ::core::option::Option<&IVBSAXLocator>, strerrormessage: *mut ::windows_core::BSTR, nerrorcode: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXErrorHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXErrorHandler_Vtbl { pub const fn new, Impl: IVBSAXErrorHandler_Impl, const OFFSET: isize>() -> IVBSAXErrorHandler_Vtbl { unsafe extern "system" fn error, Impl: IVBSAXErrorHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, olocator: *mut ::core::ffi::c_void, strerrormessage: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, nerrorcode: i32) -> ::windows_core::HRESULT { @@ -3160,8 +3148,8 @@ impl IVBSAXErrorHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXLexicalHandler_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn startDTD(&self, strname: *mut ::windows_core::BSTR, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn endDTD(&self) -> ::windows_core::Result<()>; @@ -3171,9 +3159,9 @@ pub trait IVBSAXLexicalHandler_Impl: Sized + super::super::super::System::Com::I fn endCDATA(&self) -> ::windows_core::Result<()>; fn comment(&self, strchars: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXLexicalHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXLexicalHandler_Vtbl { pub const fn new, Impl: IVBSAXLexicalHandler_Impl, const OFFSET: isize>() -> IVBSAXLexicalHandler_Vtbl { unsafe extern "system" fn startDTD, Impl: IVBSAXLexicalHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3226,17 +3214,17 @@ impl IVBSAXLexicalHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXLocator_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn columnNumber(&self) -> ::windows_core::Result; fn lineNumber(&self) -> ::windows_core::Result; fn publicId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn systemId(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXLocator_Vtbl { pub const fn new, Impl: IVBSAXLocator_Impl, const OFFSET: isize>() -> IVBSAXLocator_Vtbl { unsafe extern "system" fn columnNumber, Impl: IVBSAXLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ncolumn: *mut i32) -> ::windows_core::HRESULT { @@ -3295,15 +3283,15 @@ impl IVBSAXLocator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXXMLFilter_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn parent(&self) -> ::windows_core::Result; fn putref_parent(&self, oreader: ::core::option::Option<&IVBSAXXMLReader>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXXMLFilter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXXMLFilter_Vtbl { pub const fn new, Impl: IVBSAXXMLFilter_Impl, const OFFSET: isize>() -> IVBSAXXMLFilter_Vtbl { unsafe extern "system" fn parent, Impl: IVBSAXXMLFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, oreader: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3332,13 +3320,13 @@ impl IVBSAXXMLFilter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IVBSAXXMLReader_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn getFeature(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; fn putFeature(&self, strname: &::windows_core::BSTR, fvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn getProperty(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; - fn putProperty(&self, strname: &::windows_core::BSTR, varvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getProperty(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn putProperty(&self, strname: &::windows_core::BSTR, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn entityResolver(&self) -> ::windows_core::Result; fn putref_entityResolver(&self, oresolver: ::core::option::Option<&IVBSAXEntityResolver>) -> ::windows_core::Result<()>; fn contentHandler(&self) -> ::windows_core::Result; @@ -3351,12 +3339,12 @@ pub trait IVBSAXXMLReader_Impl: Sized + super::super::super::System::Com::IDispa fn SetbaseURL(&self, strbaseurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn secureBaseURL(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetsecureBaseURL(&self, strsecurebaseurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn parse(&self, varinput: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn parse(&self, varinput: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn parseURL(&self, strurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IVBSAXXMLReader {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IVBSAXXMLReader_Vtbl { pub const fn new, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>() -> IVBSAXXMLReader_Vtbl { unsafe extern "system" fn getFeature, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3375,7 +3363,7 @@ impl IVBSAXXMLReader_Vtbl { let this = (*this).get_impl(); this.putFeature(::core::mem::transmute(&strname), ::core::mem::transmute_copy(&fvalue)).into() } - unsafe extern "system" fn getProperty, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getProperty, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getProperty(::core::mem::transmute(&strname)) { @@ -3386,7 +3374,7 @@ impl IVBSAXXMLReader_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn putProperty, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn putProperty, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.putProperty(::core::mem::transmute(&strname), ::core::mem::transmute(&varvalue)).into() @@ -3487,7 +3475,7 @@ impl IVBSAXXMLReader_Vtbl { let this = (*this).get_impl(); this.SetsecureBaseURL(::core::mem::transmute(&strsecurebaseurl)).into() } - unsafe extern "system" fn parse, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn parse, Impl: IVBSAXXMLReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinput: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.parse(::core::mem::transmute(&varinput)).into() @@ -3523,15 +3511,15 @@ impl IVBSAXXMLReader_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLAttribute_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn value(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLAttribute {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLAttribute_Vtbl { pub const fn new, Impl: IXMLAttribute_Impl, const OFFSET: isize>() -> IXMLAttribute_Vtbl { unsafe extern "system" fn name, Impl: IXMLAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, n: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3566,16 +3554,16 @@ impl IXMLAttribute_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMAttribute_Impl: Sized + IXMLDOMNode_Impl { fn name(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn value(&self) -> ::windows_core::Result; - fn Setvalue(&self, attributevalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Setvalue(&self, attributevalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMAttribute {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMAttribute_Vtbl { pub const fn new, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>() -> IXMLDOMAttribute_Vtbl { unsafe extern "system" fn name, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3589,7 +3577,7 @@ impl IXMLDOMAttribute_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn value, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributevalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn value, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributevalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.value() { @@ -3600,7 +3588,7 @@ impl IXMLDOMAttribute_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Setvalue, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributevalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setvalue, Impl: IXMLDOMAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributevalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setvalue(::core::mem::transmute(&attributevalue)).into() @@ -3616,12 +3604,12 @@ impl IXMLDOMAttribute_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMCDATASection_Impl: Sized + IXMLDOMText_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMCDATASection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMCDATASection_Vtbl { pub const fn new, Impl: IXMLDOMCDATASection_Impl, const OFFSET: isize>() -> IXMLDOMCDATASection_Vtbl { Self { base__: IXMLDOMText_Vtbl::new::() } @@ -3630,8 +3618,8 @@ impl IXMLDOMCDATASection_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMCharacterData_Impl: Sized + IXMLDOMNode_Impl { fn data(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Setdata(&self, data: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3642,9 +3630,9 @@ pub trait IXMLDOMCharacterData_Impl: Sized + IXMLDOMNode_Impl { fn deleteData(&self, offset: i32, count: i32) -> ::windows_core::Result<()>; fn replaceData(&self, offset: i32, count: i32, data: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMCharacterData {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMCharacterData_Vtbl { pub const fn new, Impl: IXMLDOMCharacterData_Impl, const OFFSET: isize>() -> IXMLDOMCharacterData_Vtbl { unsafe extern "system" fn data, Impl: IXMLDOMCharacterData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3721,12 +3709,12 @@ impl IXMLDOMCharacterData_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMComment_Impl: Sized + IXMLDOMCharacterData_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMComment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMComment_Vtbl { pub const fn new, Impl: IXMLDOMComment_Impl, const OFFSET: isize>() -> IXMLDOMComment_Vtbl { Self { base__: IXMLDOMCharacterData_Vtbl::new::() } @@ -3735,8 +3723,8 @@ impl IXMLDOMComment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMDocument_Impl: Sized + IXMLDOMNode_Impl { fn doctype(&self) -> ::windows_core::Result; fn implementation(&self) -> ::windows_core::Result; @@ -3751,9 +3739,9 @@ pub trait IXMLDOMDocument_Impl: Sized + IXMLDOMNode_Impl { fn createAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn createEntityReference(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn getElementsByTagName(&self, tagname: &::windows_core::BSTR) -> ::windows_core::Result; - fn createNode(&self, r#type: &super::super::super::System::Variant::VARIANT, name: &::windows_core::BSTR, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; + fn createNode(&self, r#type: &::windows_core::VARIANT, name: &::windows_core::BSTR, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; fn nodeFromID(&self, idstring: &::windows_core::BSTR) -> ::windows_core::Result; - fn load(&self, xmlsource: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn load(&self, xmlsource: &::windows_core::VARIANT) -> ::windows_core::Result; fn readyState(&self) -> ::windows_core::Result; fn parseError(&self) -> ::windows_core::Result; fn url(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3761,20 +3749,20 @@ pub trait IXMLDOMDocument_Impl: Sized + IXMLDOMNode_Impl { fn Setasync(&self, isasync: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn abort(&self) -> ::windows_core::Result<()>; fn loadXML(&self, bstrxml: &::windows_core::BSTR) -> ::windows_core::Result; - fn save(&self, destination: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn save(&self, destination: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn validateOnParse(&self) -> ::windows_core::Result; fn SetvalidateOnParse(&self, isvalidating: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn resolveExternals(&self) -> ::windows_core::Result; fn SetresolveExternals(&self, isresolving: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn preserveWhiteSpace(&self) -> ::windows_core::Result; fn SetpreserveWhiteSpace(&self, ispreserving: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn Setonreadystatechange(&self, readystatechangesink: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Setondataavailable(&self, ondataavailablesink: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Setontransformnode(&self, ontransformnodesink: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Setonreadystatechange(&self, readystatechangesink: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Setondataavailable(&self, ondataavailablesink: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Setontransformnode(&self, ontransformnodesink: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMDocument {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMDocument_Vtbl { pub const fn new, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>() -> IXMLDOMDocument_Vtbl { unsafe extern "system" fn doctype, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, documenttype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3914,7 +3902,7 @@ impl IXMLDOMDocument_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn createNode, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: super::super::super::System::Variant::VARIANT, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn createNode, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: ::std::mem::MaybeUninit<::windows_core::VARIANT>, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.createNode(::core::mem::transmute(&r#type), ::core::mem::transmute(&name), ::core::mem::transmute(&namespaceuri)) { @@ -3936,7 +3924,7 @@ impl IXMLDOMDocument_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn load, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xmlsource: super::super::super::System::Variant::VARIANT, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn load, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xmlsource: ::std::mem::MaybeUninit<::windows_core::VARIANT>, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.load(::core::mem::transmute(&xmlsource)) { @@ -4012,7 +4000,7 @@ impl IXMLDOMDocument_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn save, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destination: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn save, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destination: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.save(::core::mem::transmute(&destination)).into() @@ -4065,17 +4053,17 @@ impl IXMLDOMDocument_Vtbl { let this = (*this).get_impl(); this.SetpreserveWhiteSpace(::core::mem::transmute_copy(&ispreserving)).into() } - unsafe extern "system" fn Setonreadystatechange, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, readystatechangesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setonreadystatechange, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, readystatechangesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setonreadystatechange(::core::mem::transmute(&readystatechangesink)).into() } - unsafe extern "system" fn Setondataavailable, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ondataavailablesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setondataavailable, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ondataavailablesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setondataavailable(::core::mem::transmute(&ondataavailablesink)).into() } - unsafe extern "system" fn Setontransformnode, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ontransformnodesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setontransformnode, Impl: IXMLDOMDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ontransformnodesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setontransformnode(::core::mem::transmute(&ontransformnodesink)).into() @@ -4121,19 +4109,19 @@ impl IXMLDOMDocument_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMDocument2_Impl: Sized + IXMLDOMDocument_Impl { fn namespaces(&self) -> ::windows_core::Result; - fn schemas(&self) -> ::windows_core::Result; - fn putref_schemas(&self, othercollection: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn schemas(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn putref_schemas(&self, othercollection: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn validate(&self) -> ::windows_core::Result; - fn setProperty(&self, name: &::windows_core::BSTR, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn getProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; + fn setProperty(&self, name: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn getProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMDocument2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMDocument2_Vtbl { pub const fn new, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>() -> IXMLDOMDocument2_Vtbl { unsafe extern "system" fn namespaces, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespacecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4147,7 +4135,7 @@ impl IXMLDOMDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn schemas, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, othercollection: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn schemas, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, othercollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.schemas() { @@ -4158,7 +4146,7 @@ impl IXMLDOMDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn putref_schemas, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, othercollection: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn putref_schemas, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, othercollection: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.putref_schemas(::core::mem::transmute(&othercollection)).into() @@ -4174,12 +4162,12 @@ impl IXMLDOMDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setProperty, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setProperty, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setProperty(::core::mem::transmute(&name), ::core::mem::transmute(&value)).into() } - unsafe extern "system" fn getProperty, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getProperty, Impl: IXMLDOMDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getProperty(::core::mem::transmute(&name)) { @@ -4204,15 +4192,15 @@ impl IXMLDOMDocument2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMDocument3_Impl: Sized + IXMLDOMDocument2_Impl { fn validateNode(&self, node: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; fn importNode(&self, node: ::core::option::Option<&IXMLDOMNode>, deep: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMDocument3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMDocument3_Vtbl { pub const fn new, Impl: IXMLDOMDocument3_Impl, const OFFSET: isize>() -> IXMLDOMDocument3_Vtbl { unsafe extern "system" fn validateNode, Impl: IXMLDOMDocument3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, node: *mut ::core::ffi::c_void, errorobj: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4247,12 +4235,12 @@ impl IXMLDOMDocument3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMDocumentFragment_Impl: Sized + IXMLDOMNode_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMDocumentFragment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMDocumentFragment_Vtbl { pub const fn new, Impl: IXMLDOMDocumentFragment_Impl, const OFFSET: isize>() -> IXMLDOMDocumentFragment_Vtbl { Self { base__: IXMLDOMNode_Vtbl::new::() } @@ -4261,16 +4249,16 @@ impl IXMLDOMDocumentFragment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMDocumentType_Impl: Sized + IXMLDOMNode_Impl { fn name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn entities(&self) -> ::windows_core::Result; fn notations(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMDocumentType {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMDocumentType_Vtbl { pub const fn new, Impl: IXMLDOMDocumentType_Impl, const OFFSET: isize>() -> IXMLDOMDocumentType_Vtbl { unsafe extern "system" fn name, Impl: IXMLDOMDocumentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rootname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4317,12 +4305,12 @@ impl IXMLDOMDocumentType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMElement_Impl: Sized + IXMLDOMNode_Impl { fn tagName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; - fn setAttribute(&self, name: &::windows_core::BSTR, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setAttribute(&self, name: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn removeAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn getAttributeNode(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn setAttributeNode(&self, domattribute: ::core::option::Option<&IXMLDOMAttribute>) -> ::windows_core::Result; @@ -4330,9 +4318,9 @@ pub trait IXMLDOMElement_Impl: Sized + IXMLDOMNode_Impl { fn getElementsByTagName(&self, tagname: &::windows_core::BSTR) -> ::windows_core::Result; fn normalize(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMElement_Vtbl { pub const fn new, Impl: IXMLDOMElement_Impl, const OFFSET: isize>() -> IXMLDOMElement_Vtbl { unsafe extern "system" fn tagName, Impl: IXMLDOMElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tagname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4346,7 +4334,7 @@ impl IXMLDOMElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getAttribute, Impl: IXMLDOMElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getAttribute, Impl: IXMLDOMElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getAttribute(::core::mem::transmute(&name)) { @@ -4357,7 +4345,7 @@ impl IXMLDOMElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setAttribute, Impl: IXMLDOMElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttribute, Impl: IXMLDOMElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute(&name), ::core::mem::transmute(&value)).into() @@ -4433,19 +4421,19 @@ impl IXMLDOMElement_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMEntity_Impl: Sized + IXMLDOMNode_Impl { - fn publicId(&self) -> ::windows_core::Result; - fn systemId(&self) -> ::windows_core::Result; + fn publicId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn systemId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn notationName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMEntity {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMEntity_Vtbl { pub const fn new, Impl: IXMLDOMEntity_Impl, const OFFSET: isize>() -> IXMLDOMEntity_Vtbl { - unsafe extern "system" fn publicId, Impl: IXMLDOMEntity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, publicid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn publicId, Impl: IXMLDOMEntity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, publicid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.publicId() { @@ -4456,7 +4444,7 @@ impl IXMLDOMEntity_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn systemId, Impl: IXMLDOMEntity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, systemid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn systemId, Impl: IXMLDOMEntity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, systemid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.systemId() { @@ -4489,12 +4477,12 @@ impl IXMLDOMEntity_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMEntityReference_Impl: Sized + IXMLDOMNode_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMEntityReference {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMEntityReference_Vtbl { pub const fn new, Impl: IXMLDOMEntityReference_Impl, const OFFSET: isize>() -> IXMLDOMEntityReference_Vtbl { Self { base__: IXMLDOMNode_Vtbl::new::() } @@ -4503,14 +4491,14 @@ impl IXMLDOMEntityReference_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMImplementation_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn hasFeature(&self, feature: &::windows_core::BSTR, version: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMImplementation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMImplementation_Vtbl { pub const fn new, Impl: IXMLDOMImplementation_Impl, const OFFSET: isize>() -> IXMLDOMImplementation_Vtbl { unsafe extern "system" fn hasFeature, Impl: IXMLDOMImplementation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, feature: ::std::mem::MaybeUninit<::windows_core::BSTR>, version: ::std::mem::MaybeUninit<::windows_core::BSTR>, hasfeature: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4530,8 +4518,8 @@ impl IXMLDOMImplementation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMNamedNodeMap_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn getNamedItem(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn setNamedItem(&self, newitem: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; @@ -4544,9 +4532,9 @@ pub trait IXMLDOMNamedNodeMap_Impl: Sized + super::super::super::System::Com::ID fn reset(&self) -> ::windows_core::Result<()>; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMNamedNodeMap {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMNamedNodeMap_Vtbl { pub const fn new, Impl: IXMLDOMNamedNodeMap_Impl, const OFFSET: isize>() -> IXMLDOMNamedNodeMap_Vtbl { unsafe extern "system" fn getNamedItem, Impl: IXMLDOMNamedNodeMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, nameditem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4671,12 +4659,12 @@ impl IXMLDOMNamedNodeMap_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMNode_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn nodeName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn nodeValue(&self) -> ::windows_core::Result; - fn SetnodeValue(&self, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetnodeValue(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn nodeType(&self) -> ::windows_core::Result; fn parentNode(&self) -> ::windows_core::Result; fn childNodes(&self) -> ::windows_core::Result; @@ -4685,7 +4673,7 @@ pub trait IXMLDOMNode_Impl: Sized + super::super::super::System::Com::IDispatch_ fn previousSibling(&self) -> ::windows_core::Result; fn nextSibling(&self) -> ::windows_core::Result; fn attributes(&self) -> ::windows_core::Result; - fn insertBefore(&self, newchild: ::core::option::Option<&IXMLDOMNode>, refchild: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn insertBefore(&self, newchild: ::core::option::Option<&IXMLDOMNode>, refchild: &::windows_core::VARIANT) -> ::windows_core::Result; fn replaceChild(&self, newchild: ::core::option::Option<&IXMLDOMNode>, oldchild: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; fn removeChild(&self, childnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; fn appendChild(&self, newchild: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; @@ -4697,9 +4685,9 @@ pub trait IXMLDOMNode_Impl: Sized + super::super::super::System::Com::IDispatch_ fn Settext(&self, text: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn specified(&self) -> ::windows_core::Result; fn definition(&self) -> ::windows_core::Result; - fn nodeTypedValue(&self) -> ::windows_core::Result; - fn SetnodeTypedValue(&self, typedvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn dataType(&self) -> ::windows_core::Result; + fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetnodeTypedValue(&self, typedvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetdataType(&self, datatypename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn xml(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn transformNode(&self, stylesheet: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4709,11 +4697,11 @@ pub trait IXMLDOMNode_Impl: Sized + super::super::super::System::Com::IDispatch_ fn namespaceURI(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn prefix(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn baseName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn transformNodeToObject(&self, stylesheet: ::core::option::Option<&IXMLDOMNode>, outputobject: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn transformNodeToObject(&self, stylesheet: ::core::option::Option<&IXMLDOMNode>, outputobject: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMNode {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMNode_Vtbl { pub const fn new, Impl: IXMLDOMNode_Impl, const OFFSET: isize>() -> IXMLDOMNode_Vtbl { unsafe extern "system" fn nodeName, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4727,7 +4715,7 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn nodeValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn nodeValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.nodeValue() { @@ -4738,7 +4726,7 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetnodeValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetnodeValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetnodeValue(::core::mem::transmute(&value)).into() @@ -4831,7 +4819,7 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn insertBefore, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newchild: *mut ::core::ffi::c_void, refchild: super::super::super::System::Variant::VARIANT, outnewchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn insertBefore, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newchild: *mut ::core::ffi::c_void, refchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, outnewchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.insertBefore(::windows_core::from_raw_borrowed(&newchild), ::core::mem::transmute(&refchild)) { @@ -4957,7 +4945,7 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn nodeTypedValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typedvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn nodeTypedValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typedvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.nodeTypedValue() { @@ -4968,12 +4956,12 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetnodeTypedValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetnodeTypedValue, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typedvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetnodeTypedValue(::core::mem::transmute(&typedvalue)).into() } - unsafe extern "system" fn dataType, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, datatypename: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn dataType, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, datatypename: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.dataType() { @@ -5077,7 +5065,7 @@ impl IXMLDOMNode_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn transformNodeToObject, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, stylesheet: *mut ::core::ffi::c_void, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn transformNodeToObject, Impl: IXMLDOMNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, stylesheet: *mut ::core::ffi::c_void, outputobject: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.transformNodeToObject(::windows_core::from_raw_borrowed(&stylesheet), ::core::mem::transmute(&outputobject)).into() @@ -5126,8 +5114,8 @@ impl IXMLDOMNode_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMNodeList_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_item(&self, index: i32) -> ::windows_core::Result; fn length(&self) -> ::windows_core::Result; @@ -5135,9 +5123,9 @@ pub trait IXMLDOMNodeList_Impl: Sized + super::super::super::System::Com::IDispa fn reset(&self) -> ::windows_core::Result<()>; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMNodeList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMNodeList_Vtbl { pub const fn new, Impl: IXMLDOMNodeList_Impl, const OFFSET: isize>() -> IXMLDOMNodeList_Vtbl { unsafe extern "system" fn get_item, Impl: IXMLDOMNodeList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, listitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5202,18 +5190,18 @@ impl IXMLDOMNodeList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMNotation_Impl: Sized + IXMLDOMNode_Impl { - fn publicId(&self) -> ::windows_core::Result; - fn systemId(&self) -> ::windows_core::Result; + fn publicId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn systemId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMNotation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMNotation_Vtbl { pub const fn new, Impl: IXMLDOMNotation_Impl, const OFFSET: isize>() -> IXMLDOMNotation_Vtbl { - unsafe extern "system" fn publicId, Impl: IXMLDOMNotation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, publicid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn publicId, Impl: IXMLDOMNotation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, publicid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.publicId() { @@ -5224,7 +5212,7 @@ impl IXMLDOMNotation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn systemId, Impl: IXMLDOMNotation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, systemid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn systemId, Impl: IXMLDOMNotation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, systemid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.systemId() { @@ -5245,8 +5233,8 @@ impl IXMLDOMNotation_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMParseError_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn errorCode(&self) -> ::windows_core::Result; fn url(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5256,9 +5244,9 @@ pub trait IXMLDOMParseError_Impl: Sized + super::super::super::System::Com::IDis fn linepos(&self) -> ::windows_core::Result; fn filepos(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMParseError {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMParseError_Vtbl { pub const fn new, Impl: IXMLDOMParseError_Impl, const OFFSET: isize>() -> IXMLDOMParseError_Vtbl { unsafe extern "system" fn errorCode, Impl: IXMLDOMParseError_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, errorcode: *mut i32) -> ::windows_core::HRESULT { @@ -5353,17 +5341,17 @@ impl IXMLDOMParseError_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMParseError2_Impl: Sized + IXMLDOMParseError_Impl { fn errorXPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn allErrors(&self) -> ::windows_core::Result; fn errorParameters(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn errorParametersCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMParseError2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMParseError2_Vtbl { pub const fn new, Impl: IXMLDOMParseError2_Impl, const OFFSET: isize>() -> IXMLDOMParseError2_Vtbl { unsafe extern "system" fn errorXPath, Impl: IXMLDOMParseError2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xpathexpr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5422,8 +5410,8 @@ impl IXMLDOMParseError2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMParseErrorCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_item(&self, index: i32) -> ::windows_core::Result; fn length(&self) -> ::windows_core::Result; @@ -5431,9 +5419,9 @@ pub trait IXMLDOMParseErrorCollection_Impl: Sized + super::super::super::System: fn reset(&self) -> ::windows_core::Result<()>; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMParseErrorCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMParseErrorCollection_Vtbl { pub const fn new, Impl: IXMLDOMParseErrorCollection_Impl, const OFFSET: isize>() -> IXMLDOMParseErrorCollection_Vtbl { unsafe extern "system" fn get_item, Impl: IXMLDOMParseErrorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, error: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5498,16 +5486,16 @@ impl IXMLDOMParseErrorCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMProcessingInstruction_Impl: Sized + IXMLDOMNode_Impl { fn target(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn data(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Setdata(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMProcessingInstruction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMProcessingInstruction_Vtbl { pub const fn new, Impl: IXMLDOMProcessingInstruction_Impl, const OFFSET: isize>() -> IXMLDOMProcessingInstruction_Vtbl { unsafe extern "system" fn target, Impl: IXMLDOMProcessingInstruction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5548,10 +5536,10 @@ impl IXMLDOMProcessingInstruction_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMSchemaCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn add(&self, namespaceuri: &::windows_core::BSTR, var: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn add(&self, namespaceuri: &::windows_core::BSTR, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn get(&self, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; fn remove(&self, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn length(&self) -> ::windows_core::Result; @@ -5559,12 +5547,12 @@ pub trait IXMLDOMSchemaCollection_Impl: Sized + super::super::super::System::Com fn addCollection(&self, othercollection: ::core::option::Option<&IXMLDOMSchemaCollection>) -> ::windows_core::Result<()>; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMSchemaCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMSchemaCollection_Vtbl { pub const fn new, Impl: IXMLDOMSchemaCollection_Impl, const OFFSET: isize>() -> IXMLDOMSchemaCollection_Vtbl { - unsafe extern "system" fn add, Impl: IXMLDOMSchemaCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn add, Impl: IXMLDOMSchemaCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.add(::core::mem::transmute(&namespaceuri), ::core::mem::transmute(&var)).into() @@ -5638,8 +5626,8 @@ impl IXMLDOMSchemaCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMSchemaCollection2_Impl: Sized + IXMLDOMSchemaCollection_Impl { fn validate(&self) -> ::windows_core::Result<()>; fn SetvalidateOnLoad(&self, validateonload: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5647,9 +5635,9 @@ pub trait IXMLDOMSchemaCollection2_Impl: Sized + IXMLDOMSchemaCollection_Impl { fn getSchema(&self, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; fn getDeclaration(&self, node: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMSchemaCollection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMSchemaCollection2_Vtbl { pub const fn new, Impl: IXMLDOMSchemaCollection2_Impl, const OFFSET: isize>() -> IXMLDOMSchemaCollection2_Vtbl { unsafe extern "system" fn validate, Impl: IXMLDOMSchemaCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5708,8 +5696,8 @@ impl IXMLDOMSchemaCollection2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMSelection_Impl: Sized + IXMLDOMNodeList_Impl { fn expr(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Setexpr(&self, expression: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5720,12 +5708,12 @@ pub trait IXMLDOMSelection_Impl: Sized + IXMLDOMNodeList_Impl { fn removeNext(&self) -> ::windows_core::Result; fn removeAll(&self) -> ::windows_core::Result<()>; fn clone(&self) -> ::windows_core::Result; - fn getProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; - fn setProperty(&self, name: &::windows_core::BSTR, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setProperty(&self, name: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMSelection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMSelection_Vtbl { pub const fn new, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>() -> IXMLDOMSelection_Vtbl { unsafe extern "system" fn expr, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, expression: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5809,7 +5797,7 @@ impl IXMLDOMSelection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getProperty, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getProperty, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getProperty(::core::mem::transmute(&name)) { @@ -5820,7 +5808,7 @@ impl IXMLDOMSelection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setProperty, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setProperty, Impl: IXMLDOMSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setProperty(::core::mem::transmute(&name), ::core::mem::transmute(&value)).into() @@ -5844,14 +5832,14 @@ impl IXMLDOMSelection_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDOMText_Impl: Sized + IXMLDOMCharacterData_Impl { fn splitText(&self, offset: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDOMText {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDOMText_Vtbl { pub const fn new, Impl: IXMLDOMText_Impl, const OFFSET: isize>() -> IXMLDOMText_Vtbl { unsafe extern "system" fn splitText, Impl: IXMLDOMText_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, offset: i32, righthandtextnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5871,8 +5859,8 @@ impl IXMLDOMText_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDSOControl_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn XMLDocument(&self) -> ::windows_core::Result; fn SetXMLDocument(&self, ppdoc: ::core::option::Option<&IXMLDOMDocument>) -> ::windows_core::Result<()>; @@ -5880,9 +5868,9 @@ pub trait IXMLDSOControl_Impl: Sized + super::super::super::System::Com::IDispat fn SetJavaDSOCompatible(&self, fjavadsocompatible: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn readyState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDSOControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDSOControl_Vtbl { pub const fn new, Impl: IXMLDSOControl_Impl, const OFFSET: isize>() -> IXMLDSOControl_Vtbl { unsafe extern "system" fn XMLDocument, Impl: IXMLDSOControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdoc: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5941,8 +5929,8 @@ impl IXMLDSOControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDocument_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn root(&self) -> ::windows_core::Result; fn fileSize(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5957,11 +5945,11 @@ pub trait IXMLDocument_Impl: Sized + super::super::super::System::Com::IDispatch fn version(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn doctype(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn dtdURL(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn createElement(&self, vtype: &super::super::super::System::Variant::VARIANT, var1: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn createElement(&self, vtype: &::windows_core::VARIANT, var1: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDocument {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDocument_Vtbl { pub const fn new, Impl: IXMLDocument_Impl, const OFFSET: isize>() -> IXMLDocument_Vtbl { unsafe extern "system" fn root, Impl: IXMLDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6095,7 +6083,7 @@ impl IXMLDocument_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn createElement, Impl: IXMLDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn createElement, Impl: IXMLDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.createElement(::core::mem::transmute(&vtype), ::core::mem::transmute(&var1)) { @@ -6128,8 +6116,8 @@ impl IXMLDocument_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLDocument2_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn root(&self) -> ::windows_core::Result; fn fileSize(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6144,13 +6132,13 @@ pub trait IXMLDocument2_Impl: Sized + super::super::super::System::Com::IDispatc fn version(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn doctype(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn dtdURL(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn createElement(&self, vtype: &super::super::super::System::Variant::VARIANT, var1: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn createElement(&self, vtype: &::windows_core::VARIANT, var1: &::windows_core::VARIANT) -> ::windows_core::Result; fn r#async(&self) -> ::windows_core::Result; fn Setasync(&self, f: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLDocument2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLDocument2_Vtbl { pub const fn new, Impl: IXMLDocument2_Impl, const OFFSET: isize>() -> IXMLDocument2_Vtbl { unsafe extern "system" fn root, Impl: IXMLDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6284,7 +6272,7 @@ impl IXMLDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn createElement, Impl: IXMLDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn createElement, Impl: IXMLDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.createElement(::core::mem::transmute(&vtype), ::core::mem::transmute(&var1)) { @@ -6335,14 +6323,14 @@ impl IXMLDocument2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLElement_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn tagName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SettagName(&self, p: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn parent(&self) -> ::windows_core::Result; - fn setAttribute(&self, strpropertyname: &::windows_core::BSTR, propertyvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn getAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; + fn setAttribute(&self, strpropertyname: &::windows_core::BSTR, propertyvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn getAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn removeAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn children(&self) -> ::windows_core::Result; fn r#type(&self) -> ::windows_core::Result; @@ -6351,9 +6339,9 @@ pub trait IXMLElement_Impl: Sized + super::super::super::System::Com::IDispatch_ fn addChild(&self, pchildelem: ::core::option::Option<&IXMLElement>, lindex: i32, lreserved: i32) -> ::windows_core::Result<()>; fn removeChild(&self, pchildelem: ::core::option::Option<&IXMLElement>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLElement_Vtbl { pub const fn new, Impl: IXMLElement_Impl, const OFFSET: isize>() -> IXMLElement_Vtbl { unsafe extern "system" fn tagName, Impl: IXMLElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6383,12 +6371,12 @@ impl IXMLElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setAttribute, Impl: IXMLElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttribute, Impl: IXMLElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute(&strpropertyname), ::core::mem::transmute(&propertyvalue)).into() } - unsafe extern "system" fn getAttribute, Impl: IXMLElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getAttribute, Impl: IXMLElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getAttribute(::core::mem::transmute(&strpropertyname)) { @@ -6472,14 +6460,14 @@ impl IXMLElement_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLElement2_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn tagName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SettagName(&self, p: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn parent(&self) -> ::windows_core::Result; - fn setAttribute(&self, strpropertyname: &::windows_core::BSTR, propertyvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn getAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; + fn setAttribute(&self, strpropertyname: &::windows_core::BSTR, propertyvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn getAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn removeAttribute(&self, strpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn children(&self) -> ::windows_core::Result; fn r#type(&self) -> ::windows_core::Result; @@ -6489,9 +6477,9 @@ pub trait IXMLElement2_Impl: Sized + super::super::super::System::Com::IDispatch fn removeChild(&self, pchildelem: ::core::option::Option<&IXMLElement2>) -> ::windows_core::Result<()>; fn attributes(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLElement2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLElement2_Vtbl { pub const fn new, Impl: IXMLElement2_Impl, const OFFSET: isize>() -> IXMLElement2_Vtbl { unsafe extern "system" fn tagName, Impl: IXMLElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6521,12 +6509,12 @@ impl IXMLElement2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setAttribute, Impl: IXMLElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttribute, Impl: IXMLElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute(&strpropertyname), ::core::mem::transmute(&propertyvalue)).into() } - unsafe extern "system" fn getAttribute, Impl: IXMLElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getAttribute, Impl: IXMLElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getAttribute(::core::mem::transmute(&strpropertyname)) { @@ -6622,17 +6610,17 @@ impl IXMLElement2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLElementCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Setlength(&self, v: i32) -> ::windows_core::Result<()>; fn length(&self) -> ::windows_core::Result; fn _newEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn item(&self, var1: &super::super::super::System::Variant::VARIANT, var2: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn item(&self, var1: &::windows_core::VARIANT, var2: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLElementCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLElementCollection_Vtbl { pub const fn new, Impl: IXMLElementCollection_Impl, const OFFSET: isize>() -> IXMLElementCollection_Vtbl { unsafe extern "system" fn Setlength, Impl: IXMLElementCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: i32) -> ::windows_core::HRESULT { @@ -6662,7 +6650,7 @@ impl IXMLElementCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn item, Impl: IXMLElementCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var1: super::super::super::System::Variant::VARIANT, var2: super::super::super::System::Variant::VARIANT, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn item, Impl: IXMLElementCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var2: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.item(::core::mem::transmute(&var1), ::core::mem::transmute(&var2)) { @@ -6702,30 +6690,30 @@ impl IXMLError_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXMLHTTPRequest_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn open(&self, bstrmethod: &::windows_core::BSTR, bstrurl: &::windows_core::BSTR, varasync: &super::super::super::System::Variant::VARIANT, bstruser: &super::super::super::System::Variant::VARIANT, bstrpassword: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn open(&self, bstrmethod: &::windows_core::BSTR, bstrurl: &::windows_core::BSTR, varasync: &::windows_core::VARIANT, bstruser: &::windows_core::VARIANT, bstrpassword: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn setRequestHeader(&self, bstrheader: &::windows_core::BSTR, bstrvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn getResponseHeader(&self, bstrheader: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn getAllResponseHeaders(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn send(&self, varbody: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn send(&self, varbody: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn abort(&self) -> ::windows_core::Result<()>; fn status(&self) -> ::windows_core::Result; fn statusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn responseXML(&self) -> ::windows_core::Result; fn responseText(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn responseBody(&self) -> ::windows_core::Result; - fn responseStream(&self) -> ::windows_core::Result; + fn responseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn responseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn readyState(&self) -> ::windows_core::Result; fn Setonreadystatechange(&self, preadystatesink: ::core::option::Option<&super::super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXMLHTTPRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXMLHTTPRequest_Vtbl { pub const fn new, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>() -> IXMLHTTPRequest_Vtbl { - unsafe extern "system" fn open, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrmethod: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varasync: super::super::super::System::Variant::VARIANT, bstruser: super::super::super::System::Variant::VARIANT, bstrpassword: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn open, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrmethod: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varasync: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstruser: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.open(::core::mem::transmute(&bstrmethod), ::core::mem::transmute(&bstrurl), ::core::mem::transmute(&varasync), ::core::mem::transmute(&bstruser), ::core::mem::transmute(&bstrpassword)).into() @@ -6757,7 +6745,7 @@ impl IXMLHTTPRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn send, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn send, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.send(::core::mem::transmute(&varbody)).into() @@ -6811,7 +6799,7 @@ impl IXMLHTTPRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn responseBody, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn responseBody, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.responseBody() { @@ -6822,7 +6810,7 @@ impl IXMLHTTPRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn responseStream, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn responseStream, Impl: IXMLHTTPRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.responseStream() { @@ -7080,35 +7068,35 @@ impl IXMLHTTPRequest3Callback_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXSLProcessor_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn Setinput(&self, var: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn input(&self) -> ::windows_core::Result; + fn Setinput(&self, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn input(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn ownerTemplate(&self) -> ::windows_core::Result; fn setStartMode(&self, mode: &::windows_core::BSTR, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn startMode(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn startModeURI(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Setoutput(&self, output: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn output(&self) -> ::windows_core::Result; + fn Setoutput(&self, output: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn output(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn transform(&self) -> ::windows_core::Result; fn reset(&self) -> ::windows_core::Result<()>; fn readyState(&self) -> ::windows_core::Result; - fn addParameter(&self, basename: &::windows_core::BSTR, parameter: &super::super::super::System::Variant::VARIANT, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn addParameter(&self, basename: &::windows_core::BSTR, parameter: &::windows_core::VARIANT, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn addObject(&self, obj: ::core::option::Option<&super::super::super::System::Com::IDispatch>, namespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn stylesheet(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXSLProcessor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXSLProcessor_Vtbl { pub const fn new, Impl: IXSLProcessor_Impl, const OFFSET: isize>() -> IXSLProcessor_Vtbl { - unsafe extern "system" fn Setinput, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setinput, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setinput(::core::mem::transmute(&var)).into() } - unsafe extern "system" fn input, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn input, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.input() { @@ -7157,12 +7145,12 @@ impl IXSLProcessor_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Setoutput, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, output: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Setoutput, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, output: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Setoutput(::core::mem::transmute(&output)).into() } - unsafe extern "system" fn output, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, poutput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn output, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, poutput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.output() { @@ -7200,7 +7188,7 @@ impl IXSLProcessor_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn addParameter, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, basename: ::std::mem::MaybeUninit<::windows_core::BSTR>, parameter: super::super::super::System::Variant::VARIANT, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn addParameter, Impl: IXSLProcessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, basename: ::std::mem::MaybeUninit<::windows_core::BSTR>, parameter: ::std::mem::MaybeUninit<::windows_core::VARIANT>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.addParameter(::core::mem::transmute(&basename), ::core::mem::transmute(¶meter), ::core::mem::transmute(&namespaceuri)).into() @@ -7243,16 +7231,16 @@ impl IXSLProcessor_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXSLTemplate_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn putref_stylesheet(&self, stylesheet: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result<()>; fn stylesheet(&self) -> ::windows_core::Result; fn createProcessor(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXSLTemplate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXSLTemplate_Vtbl { pub const fn new, Impl: IXSLTemplate_Impl, const OFFSET: isize>() -> IXSLTemplate_Vtbl { unsafe extern "system" fn putref_stylesheet, Impl: IXSLTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, stylesheet: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7293,8 +7281,8 @@ impl IXSLTemplate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXTLRuntime_Impl: Sized + IXMLDOMNode_Impl { fn uniqueID(&self, pnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; fn depth(&self, pnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; @@ -7303,12 +7291,12 @@ pub trait IXTLRuntime_Impl: Sized + IXMLDOMNode_Impl { fn absoluteChildNumber(&self, pnode: ::core::option::Option<&IXMLDOMNode>) -> ::windows_core::Result; fn formatIndex(&self, lindex: i32, bstrformat: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn formatNumber(&self, dblnumber: f64, bstrformat: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; - fn formatDate(&self, vardate: &super::super::super::System::Variant::VARIANT, bstrformat: &::windows_core::BSTR, vardestlocale: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn formatTime(&self, vartime: &super::super::super::System::Variant::VARIANT, bstrformat: &::windows_core::BSTR, vardestlocale: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn formatDate(&self, vardate: &::windows_core::VARIANT, bstrformat: &::windows_core::BSTR, vardestlocale: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn formatTime(&self, vartime: &::windows_core::VARIANT, bstrformat: &::windows_core::BSTR, vardestlocale: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXTLRuntime {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXTLRuntime_Vtbl { pub const fn new, Impl: IXTLRuntime_Impl, const OFFSET: isize>() -> IXTLRuntime_Vtbl { unsafe extern "system" fn uniqueID, Impl: IXTLRuntime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pnode: *mut ::core::ffi::c_void, pid: *mut i32) -> ::windows_core::HRESULT { @@ -7388,7 +7376,7 @@ impl IXTLRuntime_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn formatDate, Impl: IXTLRuntime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardate: super::super::super::System::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: super::super::super::System::Variant::VARIANT, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn formatDate, Impl: IXTLRuntime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardate: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.formatDate(::core::mem::transmute(&vardate), ::core::mem::transmute(&bstrformat), ::core::mem::transmute(&vardestlocale)) { @@ -7399,7 +7387,7 @@ impl IXTLRuntime_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn formatTime, Impl: IXTLRuntime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartime: super::super::super::System::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: super::super::super::System::Variant::VARIANT, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn formatTime, Impl: IXTLRuntime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.formatTime(::core::mem::transmute(&vartime), ::core::mem::transmute(&bstrformat), ::core::mem::transmute(&vardestlocale)) { @@ -7427,12 +7415,12 @@ impl IXTLRuntime_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait XMLDOMDocumentEvents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for XMLDOMDocumentEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl XMLDOMDocumentEvents_Vtbl { pub const fn new, Impl: XMLDOMDocumentEvents_Impl, const OFFSET: isize>() -> XMLDOMDocumentEvents_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/mod.rs b/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/mod.rs index d443502d63..9d990c9028 100644 --- a/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Data/Xml/MsXml/mod.rs @@ -19,10 +19,11 @@ impl IMXAttributes { { (::windows_core::Interface::vtable(self).addAttribute)(::windows_core::Interface::as_raw(self), struri.into_param().abi(), strlocalname.into_param().abi(), strqname.into_param().abi(), strtype.into_param().abi(), strvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn addAttributeFromIndex(&self, varatts: super::super::super::System::Variant::VARIANT, nindex: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).addAttributeFromIndex)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varatts), nindex).ok() + pub unsafe fn addAttributeFromIndex(&self, varatts: P0, nindex: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).addAttributeFromIndex)(::windows_core::Interface::as_raw(self), varatts.into_param().abi(), nindex).ok() } pub unsafe fn clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).clear)(::windows_core::Interface::as_raw(self)).ok() @@ -40,10 +41,11 @@ impl IMXAttributes { { (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), nindex, struri.into_param().abi(), strlocalname.into_param().abi(), strqname.into_param().abi(), strtype.into_param().abi(), strvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttributes(&self, varatts: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).setAttributes)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varatts)).ok() + pub unsafe fn setAttributes(&self, varatts: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).setAttributes)(::windows_core::Interface::as_raw(self), varatts.into_param().abi()).ok() } pub unsafe fn setLocalName(&self, nindex: i32, strlocalname: P0) -> ::windows_core::Result<()> where @@ -82,17 +84,11 @@ impl IMXAttributes { pub struct IMXAttributes_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub addAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, struri: ::std::mem::MaybeUninit<::windows_core::BSTR>, strlocalname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strqname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, strvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub addAttributeFromIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varatts: super::super::super::System::Variant::VARIANT, nindex: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - addAttributeFromIndex: usize, + pub addAttributeFromIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varatts: ::std::mem::MaybeUninit<::windows_core::VARIANT>, nindex: i32) -> ::windows_core::HRESULT, pub clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: i32) -> ::windows_core::HRESULT, pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: i32, struri: ::std::mem::MaybeUninit<::windows_core::BSTR>, strlocalname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strqname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, strvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varatts: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttributes: usize, + pub setAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varatts: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub setLocalName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: i32, strlocalname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub setQName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: i32, strqname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub setType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: i32, strtype: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -281,14 +277,13 @@ pub struct IMXSchemaDeclHandler_Vtbl { ::windows_core::imp::interface_hierarchy!(IMXWriter, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMXWriter { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setoutput(&self, vardestination: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setoutput)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardestination)).ok() + pub unsafe fn Setoutput(&self, vardestination: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setoutput)(::windows_core::Interface::as_raw(self), vardestination.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn output(&self) -> ::windows_core::Result { + pub unsafe fn output(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).output)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -371,14 +366,8 @@ impl IMXWriter { #[doc(hidden)] pub struct IMXWriter_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setoutput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestination: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setoutput: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub output: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestination: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - output: usize, + pub Setoutput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestination: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub output: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestination: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Setencoding: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strencoding: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub encoding: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strencoding: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetbyteOrderMark: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fwritebyteordermark: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -420,22 +409,19 @@ impl IMXXMLFilter { { (::windows_core::Interface::vtable(self).putFeature)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), fvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, strname: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, strname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putProperty(&self, strname: P0, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn putProperty(&self, strname: P0, varvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), ::core::mem::transmute(varvalue)).ok() + (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), varvalue.into_param().abi()).ok() } pub unsafe fn entityResolver(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -485,14 +471,8 @@ pub struct IMXXMLFilter_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub getFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub putFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - putProperty: usize, + pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub entityResolver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, oresolver: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub putref_entityResolver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, oresolver: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub contentHandler: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ohandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -750,9 +730,7 @@ pub struct ISAXDeclHandler_Vtbl { ::windows_core::imp::com_interface!(ISAXEntityResolver, ISAXEntityResolver_Vtbl, 0x99bca7bd_e8c4_4d5f_a0cf_6d907901ff07); ::windows_core::imp::interface_hierarchy!(ISAXEntityResolver, ::windows_core::IUnknown); impl ISAXEntityResolver { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn resolveEntity(&self, pwchpublicid: P0, pwchsystemid: P1) -> ::windows_core::Result + pub unsafe fn resolveEntity(&self, pwchpublicid: P0, pwchsystemid: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -765,10 +743,7 @@ impl ISAXEntityResolver { #[doc(hidden)] pub struct ISAXEntityResolver_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub resolveEntity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchpublicid: ::windows_core::PCWSTR, pwchsystemid: ::windows_core::PCWSTR, pvarinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - resolveEntity: usize, + pub resolveEntity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchpublicid: ::windows_core::PCWSTR, pwchsystemid: ::windows_core::PCWSTR, pvarinput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ISAXErrorHandler, ISAXErrorHandler_Vtbl, 0xa60511c4_ccf5_479e_98a3_dc8dc545b7d0); ::windows_core::imp::interface_hierarchy!(ISAXErrorHandler, ::windows_core::IUnknown); @@ -900,22 +875,19 @@ impl ISAXXMLFilter { { (::windows_core::Interface::vtable(self).base__.putFeature)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), vfvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, pwchname: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, pwchname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.getProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putProperty(&self, pwchname: P0, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn putProperty(&self, pwchname: P0, varvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.putProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), ::core::mem::transmute(varvalue)).ok() + (::windows_core::Interface::vtable(self).base__.putProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), varvalue.into_param().abi()).ok() } pub unsafe fn getEntityResolver(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -977,10 +949,11 @@ impl ISAXXMLFilter { { (::windows_core::Interface::vtable(self).base__.putSecureBaseURL)(::windows_core::Interface::as_raw(self), pwchsecurebaseurl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn parse(&self, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.parse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varinput)).ok() + pub unsafe fn parse(&self, varinput: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.parse)(::windows_core::Interface::as_raw(self), varinput.into_param().abi()).ok() } pub unsafe fn parseURL(&self, pwchurl: P0) -> ::windows_core::Result<()> where @@ -1023,22 +996,19 @@ impl ISAXXMLReader { { (::windows_core::Interface::vtable(self).putFeature)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), vfvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, pwchname: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, pwchname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putProperty(&self, pwchname: P0, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn putProperty(&self, pwchname: P0, varvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), ::core::mem::transmute(varvalue)).ok() + (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), pwchname.into_param().abi(), varvalue.into_param().abi()).ok() } pub unsafe fn getEntityResolver(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1100,10 +1070,11 @@ impl ISAXXMLReader { { (::windows_core::Interface::vtable(self).putSecureBaseURL)(::windows_core::Interface::as_raw(self), pwchsecurebaseurl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn parse(&self, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).parse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varinput)).ok() + pub unsafe fn parse(&self, varinput: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).parse)(::windows_core::Interface::as_raw(self), varinput.into_param().abi()).ok() } pub unsafe fn parseURL(&self, pwchurl: P0) -> ::windows_core::Result<()> where @@ -1118,14 +1089,8 @@ pub struct ISAXXMLReader_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub getFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvfvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub putFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, vfvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - putProperty: usize, + pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchname: ::windows_core::PCWSTR, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub getEntityResolver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppresolver: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub putEntityResolver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presolver: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub getContentHandler: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1138,10 +1103,7 @@ pub struct ISAXXMLReader_Vtbl { pub putBaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchbaseurl: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub getSecureBaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppwchsecurebaseurl: *mut *mut u16) -> ::windows_core::HRESULT, pub putSecureBaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchsecurebaseurl: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub parse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - parse: usize, + pub parse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinput: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub parseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwchurl: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -1323,15 +1285,11 @@ impl ISchemaAny { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.writeAnnotation)(::windows_core::Interface::as_raw(self), annotationsink.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minOccurs(&self) -> ::windows_core::Result { + pub unsafe fn minOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.minOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxOccurs(&self) -> ::windows_core::Result { + pub unsafe fn maxOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.maxOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1610,33 +1568,23 @@ impl ISchemaComplexType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.maxInclusive)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn totalDigits(&self) -> ::windows_core::Result { + pub unsafe fn totalDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.totalDigits)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn fractionDigits(&self) -> ::windows_core::Result { + pub unsafe fn fractionDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.fractionDigits)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn length(&self) -> ::windows_core::Result { + pub unsafe fn length(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.length)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minLength(&self) -> ::windows_core::Result { + pub unsafe fn minLength(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.minLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxLength(&self) -> ::windows_core::Result { + pub unsafe fn maxLength(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.maxLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1754,15 +1702,11 @@ impl ISchemaElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.writeAnnotation)(::windows_core::Interface::as_raw(self), annotationsink.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minOccurs(&self) -> ::windows_core::Result { + pub unsafe fn minOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.minOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxOccurs(&self) -> ::windows_core::Result { + pub unsafe fn maxOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.maxOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2103,15 +2047,11 @@ impl ISchemaModelGroup { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.writeAnnotation)(::windows_core::Interface::as_raw(self), annotationsink.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minOccurs(&self) -> ::windows_core::Result { + pub unsafe fn minOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.minOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxOccurs(&self) -> ::windows_core::Result { + pub unsafe fn maxOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.maxOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2241,15 +2181,11 @@ impl ISchemaParticle { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.writeAnnotation)(::windows_core::Interface::as_raw(self), annotationsink.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minOccurs(&self) -> ::windows_core::Result { + pub unsafe fn minOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).minOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxOccurs(&self) -> ::windows_core::Result { + pub unsafe fn maxOccurs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).maxOccurs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2259,14 +2195,8 @@ impl ISchemaParticle { #[doc(hidden)] pub struct ISchemaParticle_Vtbl { pub base__: ISchemaItem_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub minOccurs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, minoccurs: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - minOccurs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub maxOccurs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxoccurs: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - maxOccurs: usize, + pub minOccurs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, minoccurs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub maxOccurs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxoccurs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2388,33 +2318,23 @@ impl ISchemaType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).maxInclusive)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn totalDigits(&self) -> ::windows_core::Result { + pub unsafe fn totalDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).totalDigits)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn fractionDigits(&self) -> ::windows_core::Result { + pub unsafe fn fractionDigits(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).fractionDigits)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn length(&self) -> ::windows_core::Result { + pub unsafe fn length(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).length)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn minLength(&self) -> ::windows_core::Result { + pub unsafe fn minLength(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).minLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn maxLength(&self) -> ::windows_core::Result { + pub unsafe fn maxLength(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).maxLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2452,26 +2372,11 @@ pub struct ISchemaType_Vtbl { pub minInclusive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mininclusive: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub maxExclusive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxexclusive: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub maxInclusive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxinclusive: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub totalDigits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, totaldigits: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - totalDigits: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub fractionDigits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fractiondigits: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - fractionDigits: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub length: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, length: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - length: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub minLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, minlength: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - minLength: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub maxLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxlength: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - maxLength: usize, + pub totalDigits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, totaldigits: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub fractionDigits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fractiondigits: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub length: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, length: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub minLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, minlength: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub maxLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxlength: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub enumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enumeration: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2493,14 +2398,15 @@ pub struct ISchemaType_Vtbl { ::windows_core::imp::interface_hierarchy!(IServerXMLHTTPRequest, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch, IXMLHTTPRequest); #[cfg(feature = "Win32_System_Com")] impl IServerXMLHTTPRequest { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: super::super::super::System::Variant::VARIANT, bstruser: super::super::super::System::Variant::VARIANT, bstrpassword: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: P2, bstruser: P3, bstrpassword: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), ::core::mem::transmute(varasync), ::core::mem::transmute(bstruser), ::core::mem::transmute(bstrpassword)).ok() + (::windows_core::Interface::vtable(self).base__.open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), varasync.into_param().abi(), bstruser.into_param().abi(), bstrpassword.into_param().abi()).ok() } pub unsafe fn setRequestHeader(&self, bstrheader: P0, bstrvalue: P1) -> ::windows_core::Result<()> where @@ -2520,10 +2426,11 @@ impl IServerXMLHTTPRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.getAllResponseHeaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn send(&self, varbody: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.send)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn send(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.send)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } pub unsafe fn abort(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.abort)(::windows_core::Interface::as_raw(self)).ok() @@ -2546,15 +2453,11 @@ impl IServerXMLHTTPRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.responseText)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseBody(&self) -> ::windows_core::Result { + pub unsafe fn responseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.responseBody)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseStream(&self) -> ::windows_core::Result { + pub unsafe fn responseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.responseStream)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2573,22 +2476,22 @@ impl IServerXMLHTTPRequest { pub unsafe fn setTimeouts(&self, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).setTimeouts)(::windows_core::Interface::as_raw(self), resolvetimeout, connecttimeout, sendtimeout, receivetimeout).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn waitForResponse(&self, timeoutinseconds: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn waitForResponse(&self, timeoutinseconds: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).waitForResponse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(timeoutinseconds), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).waitForResponse)(::windows_core::Interface::as_raw(self), timeoutinseconds.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result { + pub unsafe fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getOption)(::windows_core::Interface::as_raw(self), option, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).setOption)(::windows_core::Interface::as_raw(self), option, ::core::mem::transmute(value)).ok() + pub unsafe fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).setOption)(::windows_core::Interface::as_raw(self), option, value.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2597,18 +2500,9 @@ impl IServerXMLHTTPRequest { pub struct IServerXMLHTTPRequest_Vtbl { pub base__: IXMLHTTPRequest_Vtbl, pub setTimeouts: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub waitForResponse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, timeoutinseconds: super::super::super::System::Variant::VARIANT, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - waitForResponse: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getOption: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setOption: usize, + pub waitForResponse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, timeoutinseconds: ::std::mem::MaybeUninit<::windows_core::VARIANT>, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub getOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: SERVERXMLHTTP_OPTION, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2621,14 +2515,15 @@ pub struct IServerXMLHTTPRequest_Vtbl { ::windows_core::imp::interface_hierarchy!(IServerXMLHTTPRequest2, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch, IXMLHTTPRequest, IServerXMLHTTPRequest); #[cfg(feature = "Win32_System_Com")] impl IServerXMLHTTPRequest2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: super::super::super::System::Variant::VARIANT, bstruser: super::super::super::System::Variant::VARIANT, bstrpassword: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: P2, bstruser: P3, bstrpassword: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), ::core::mem::transmute(varasync), ::core::mem::transmute(bstruser), ::core::mem::transmute(bstrpassword)).ok() + (::windows_core::Interface::vtable(self).base__.base__.open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), varasync.into_param().abi(), bstruser.into_param().abi(), bstrpassword.into_param().abi()).ok() } pub unsafe fn setRequestHeader(&self, bstrheader: P0, bstrvalue: P1) -> ::windows_core::Result<()> where @@ -2648,10 +2543,11 @@ impl IServerXMLHTTPRequest2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.getAllResponseHeaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn send(&self, varbody: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.send)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn send(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.send)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } pub unsafe fn abort(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.abort)(::windows_core::Interface::as_raw(self)).ok() @@ -2674,15 +2570,11 @@ impl IServerXMLHTTPRequest2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.responseText)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseBody(&self) -> ::windows_core::Result { + pub unsafe fn responseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.responseBody)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseStream(&self) -> ::windows_core::Result { + pub unsafe fn responseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.responseStream)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2701,27 +2593,29 @@ impl IServerXMLHTTPRequest2 { pub unsafe fn setTimeouts(&self, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.setTimeouts)(::windows_core::Interface::as_raw(self), resolvetimeout, connecttimeout, sendtimeout, receivetimeout).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn waitForResponse(&self, timeoutinseconds: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn waitForResponse(&self, timeoutinseconds: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.waitForResponse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(timeoutinseconds), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.waitForResponse)(::windows_core::Interface::as_raw(self), timeoutinseconds.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result { + pub unsafe fn getOption(&self, option: SERVERXMLHTTP_OPTION) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.getOption)(::windows_core::Interface::as_raw(self), option, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.setOption)(::windows_core::Interface::as_raw(self), option, ::core::mem::transmute(value)).ok() + pub unsafe fn setOption(&self, option: SERVERXMLHTTP_OPTION, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.setOption)(::windows_core::Interface::as_raw(self), option, value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setProxy(&self, proxysetting: SXH_PROXY_SETTING, varproxyserver: super::super::super::System::Variant::VARIANT, varbypasslist: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).setProxy)(::windows_core::Interface::as_raw(self), proxysetting, ::core::mem::transmute(varproxyserver), ::core::mem::transmute(varbypasslist)).ok() + pub unsafe fn setProxy(&self, proxysetting: SXH_PROXY_SETTING, varproxyserver: P0, varbypasslist: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).setProxy)(::windows_core::Interface::as_raw(self), proxysetting, varproxyserver.into_param().abi(), varbypasslist.into_param().abi()).ok() } pub unsafe fn setProxyCredentials(&self, bstrusername: P0, bstrpassword: P1) -> ::windows_core::Result<()> where @@ -2736,10 +2630,7 @@ impl IServerXMLHTTPRequest2 { #[doc(hidden)] pub struct IServerXMLHTTPRequest2_Vtbl { pub base__: IServerXMLHTTPRequest_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setProxy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proxysetting: SXH_PROXY_SETTING, varproxyserver: super::super::super::System::Variant::VARIANT, varbypasslist: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setProxy: usize, + pub setProxy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proxysetting: SXH_PROXY_SETTING, varproxyserver: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varbypasslist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub setProxyCredentials: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -2803,18 +2694,16 @@ impl IVBMXNamespaceManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getPrefixes)(::windows_core::Interface::as_raw(self), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getURI(&self, prefix: P0) -> ::windows_core::Result + pub unsafe fn getURI(&self, prefix: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getURI)(::windows_core::Interface::as_raw(self), prefix.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getURIFromNode(&self, strprefix: P0, contextnode: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn getURIFromNode(&self, strprefix: P0, contextnode: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, @@ -2846,13 +2735,10 @@ pub struct IVBMXNamespaceManager_Vtbl { pub getPrefixes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, prefixes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] getPrefixes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, uri: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getURI: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getURIFromNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strprefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, contextnode: *mut ::core::ffi::c_void, uri: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub getURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, uri: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub getURIFromNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strprefix: ::std::mem::MaybeUninit<::windows_core::BSTR>, contextnode: *mut ::core::ffi::c_void, uri: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] getURIFromNode: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3103,10 +2989,8 @@ pub struct IVBSAXDeclHandler_Vtbl { ::windows_core::imp::interface_hierarchy!(IVBSAXEntityResolver, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IVBSAXEntityResolver { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn resolveEntity(&self, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR, varinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).resolveEntity)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(strpublicid), ::core::mem::transmute(strsystemid), varinput).ok() + pub unsafe fn resolveEntity(&self, strpublicid: *mut ::windows_core::BSTR, strsystemid: *mut ::windows_core::BSTR, varinput: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).resolveEntity)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(strpublicid), ::core::mem::transmute(strsystemid), ::core::mem::transmute(varinput)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3114,10 +2998,7 @@ impl IVBSAXEntityResolver { #[doc(hidden)] pub struct IVBSAXEntityResolver_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub resolveEntity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varinput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - resolveEntity: usize, + pub resolveEntity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpublicid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, strsystemid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varinput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3322,22 +3203,19 @@ impl IVBSAXXMLReader { { (::windows_core::Interface::vtable(self).putFeature)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), fvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, strname: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, strname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putProperty(&self, strname: P0, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn putProperty(&self, strname: P0, varvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), ::core::mem::transmute(varvalue)).ok() + (::windows_core::Interface::vtable(self).putProperty)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), varvalue.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3415,10 +3293,11 @@ impl IVBSAXXMLReader { { (::windows_core::Interface::vtable(self).SetsecureBaseURL)(::windows_core::Interface::as_raw(self), strsecurebaseurl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn parse(&self, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).parse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varinput)).ok() + pub unsafe fn parse(&self, varinput: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).parse)(::windows_core::Interface::as_raw(self), varinput.into_param().abi()).ok() } pub unsafe fn parseURL(&self, strurl: P0) -> ::windows_core::Result<()> where @@ -3434,14 +3313,8 @@ pub struct IVBSAXXMLReader_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub getFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub putFeature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, fvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - putProperty: usize, + pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub putProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub entityResolver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, oresolver: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3478,10 +3351,7 @@ pub struct IVBSAXXMLReader_Vtbl { pub SetbaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strbaseurl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub secureBaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strsecurebaseurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetsecureBaseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strsecurebaseurl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub parse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinput: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - parse: usize, + pub parse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinput: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub parseURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strurl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -3527,16 +3397,15 @@ impl IXMLDOMAttribute { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3584,14 +3453,15 @@ impl IXMLDOMAttribute { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3664,20 +3534,17 @@ impl IXMLDOMAttribute { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3734,28 +3601,28 @@ impl IXMLDOMAttribute { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn value(&self) -> ::windows_core::Result { + pub unsafe fn value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setvalue(&self, attributevalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setvalue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(attributevalue)).ok() + pub unsafe fn Setvalue(&self, attributevalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setvalue)(::windows_core::Interface::as_raw(self), attributevalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3764,14 +3631,8 @@ impl IXMLDOMAttribute { pub struct IXMLDOMAttribute_Vtbl { pub base__: IXMLDOMNode_Vtbl, pub name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributevalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setvalue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributevalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setvalue: usize, + pub value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributevalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Setvalue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributevalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3788,16 +3649,15 @@ impl IXMLDOMCDATASection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3845,14 +3705,15 @@ impl IXMLDOMCDATASection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3925,20 +3786,17 @@ impl IXMLDOMCDATASection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3995,13 +3853,14 @@ impl IXMLDOMCDATASection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn data(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4070,16 +3929,15 @@ impl IXMLDOMCharacterData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4127,14 +3985,15 @@ impl IXMLDOMCharacterData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4207,20 +4066,17 @@ impl IXMLDOMCharacterData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4277,13 +4133,14 @@ impl IXMLDOMCharacterData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn data(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4354,16 +4211,15 @@ impl IXMLDOMComment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4411,14 +4267,15 @@ impl IXMLDOMComment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4491,20 +4348,17 @@ impl IXMLDOMComment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4561,13 +4415,14 @@ impl IXMLDOMComment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn data(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4630,16 +4485,15 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4687,14 +4541,15 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4767,20 +4622,17 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4837,13 +4689,14 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4950,15 +4803,16 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getElementsByTagName)(::windows_core::Interface::as_raw(self), tagname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn createNode(&self, r#type: super::super::super::System::Variant::VARIANT, name: P0, namespaceuri: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn createNode(&self, r#type: P0, name: P1, namespaceuri: P2) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).createNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(r#type), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).createNode)(::windows_core::Interface::as_raw(self), r#type.into_param().abi(), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4969,11 +4823,12 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).nodeFromID)(::windows_core::Interface::as_raw(self), idstring.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn load(&self, xmlsource: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn load(&self, xmlsource: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).load)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(xmlsource), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).load)(::windows_core::Interface::as_raw(self), xmlsource.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn readyState(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5009,10 +4864,11 @@ impl IXMLDOMDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).loadXML)(::windows_core::Interface::as_raw(self), bstrxml.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn save(&self, destination: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(destination)).ok() + pub unsafe fn save(&self, destination: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).save)(::windows_core::Interface::as_raw(self), destination.into_param().abi()).ok() } pub unsafe fn validateOnParse(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5044,20 +4900,23 @@ impl IXMLDOMDocument { { (::windows_core::Interface::vtable(self).SetpreserveWhiteSpace)(::windows_core::Interface::as_raw(self), ispreserving.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setonreadystatechange(&self, readystatechangesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setonreadystatechange)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(readystatechangesink)).ok() + pub unsafe fn Setonreadystatechange(&self, readystatechangesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setonreadystatechange)(::windows_core::Interface::as_raw(self), readystatechangesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setondataavailable(&self, ondataavailablesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setondataavailable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ondataavailablesink)).ok() + pub unsafe fn Setondataavailable(&self, ondataavailablesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setondataavailable)(::windows_core::Interface::as_raw(self), ondataavailablesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setontransformnode(&self, ontransformnodesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setontransformnode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ontransformnodesink)).ok() + pub unsafe fn Setontransformnode(&self, ontransformnodesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setontransformnode)(::windows_core::Interface::as_raw(self), ontransformnodesink.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5117,18 +4976,15 @@ pub struct IXMLDOMDocument_Vtbl { pub getElementsByTagName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tagname: ::std::mem::MaybeUninit<::windows_core::BSTR>, resultlist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] getElementsByTagName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub createNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: super::super::super::System::Variant::VARIANT, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub createNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: ::std::mem::MaybeUninit<::windows_core::VARIANT>, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] createNode: usize, #[cfg(feature = "Win32_System_Com")] pub nodeFromID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, idstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] nodeFromID: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, xmlsource: super::super::super::System::Variant::VARIANT, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - load: usize, + pub load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, xmlsource: ::std::mem::MaybeUninit<::windows_core::VARIANT>, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub readyState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub parseError: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, errorobj: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5139,28 +4995,16 @@ pub struct IXMLDOMDocument_Vtbl { pub Setasync: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, isasync: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub loadXML: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, issuccessful: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destination: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - save: usize, + pub save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destination: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub validateOnParse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, isvalidating: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetvalidateOnParse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, isvalidating: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub resolveExternals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, isresolving: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetresolveExternals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, isresolving: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub preserveWhiteSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ispreserving: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetpreserveWhiteSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ispreserving: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setonreadystatechange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, readystatechangesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setonreadystatechange: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setondataavailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ondataavailablesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setondataavailable: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setontransformnode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ontransformnodesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setontransformnode: usize, + pub Setonreadystatechange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, readystatechangesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Setondataavailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ondataavailablesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Setontransformnode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ontransformnodesink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5177,16 +5021,15 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5234,14 +5077,15 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5314,20 +5158,17 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5384,13 +5225,14 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5497,15 +5339,16 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.getElementsByTagName)(::windows_core::Interface::as_raw(self), tagname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn createNode(&self, r#type: super::super::super::System::Variant::VARIANT, name: P0, namespaceuri: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn createNode(&self, r#type: P0, name: P1, namespaceuri: P2) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.createNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(r#type), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.createNode)(::windows_core::Interface::as_raw(self), r#type.into_param().abi(), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5516,11 +5359,12 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeFromID)(::windows_core::Interface::as_raw(self), idstring.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn load(&self, xmlsource: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn load(&self, xmlsource: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.load)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(xmlsource), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.load)(::windows_core::Interface::as_raw(self), xmlsource.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn readyState(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5556,10 +5400,11 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.loadXML)(::windows_core::Interface::as_raw(self), bstrxml.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn save(&self, destination: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(destination)).ok() + pub unsafe fn save(&self, destination: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.save)(::windows_core::Interface::as_raw(self), destination.into_param().abi()).ok() } pub unsafe fn validateOnParse(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5591,20 +5436,23 @@ impl IXMLDOMDocument2 { { (::windows_core::Interface::vtable(self).base__.SetpreserveWhiteSpace)(::windows_core::Interface::as_raw(self), ispreserving.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setonreadystatechange(&self, readystatechangesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Setonreadystatechange)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(readystatechangesink)).ok() + pub unsafe fn Setonreadystatechange(&self, readystatechangesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Setonreadystatechange)(::windows_core::Interface::as_raw(self), readystatechangesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setondataavailable(&self, ondataavailablesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Setondataavailable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ondataavailablesink)).ok() + pub unsafe fn Setondataavailable(&self, ondataavailablesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Setondataavailable)(::windows_core::Interface::as_raw(self), ondataavailablesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setontransformnode(&self, ontransformnodesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Setontransformnode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ontransformnodesink)).ok() + pub unsafe fn Setontransformnode(&self, ontransformnodesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Setontransformnode)(::windows_core::Interface::as_raw(self), ontransformnodesink.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5612,16 +5460,15 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).namespaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn schemas(&self) -> ::windows_core::Result { + pub unsafe fn schemas(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).schemas)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putref_schemas(&self, othercollection: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).putref_schemas)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(othercollection)).ok() + pub unsafe fn putref_schemas(&self, othercollection: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).putref_schemas)(::windows_core::Interface::as_raw(self), othercollection.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5629,17 +5476,14 @@ impl IXMLDOMDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).validate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setProperty(&self, name: P0, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setProperty(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -5656,26 +5500,14 @@ pub struct IXMLDOMDocument2_Vtbl { pub namespaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespacecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] namespaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub schemas: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, othercollection: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - schemas: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub putref_schemas: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, othercollection: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - putref_schemas: usize, + pub schemas: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, othercollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub putref_schemas: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, othercollection: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub validate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, errorobj: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] validate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getProperty: usize, + pub setProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5692,16 +5524,15 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5749,14 +5580,15 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5829,20 +5661,17 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5899,13 +5728,14 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6012,15 +5842,16 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.getElementsByTagName)(::windows_core::Interface::as_raw(self), tagname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn createNode(&self, r#type: super::super::super::System::Variant::VARIANT, name: P0, namespaceuri: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn createNode(&self, r#type: P0, name: P1, namespaceuri: P2) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.createNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(r#type), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.createNode)(::windows_core::Interface::as_raw(self), r#type.into_param().abi(), name.into_param().abi(), namespaceuri.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6031,11 +5862,12 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeFromID)(::windows_core::Interface::as_raw(self), idstring.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn load(&self, xmlsource: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn load(&self, xmlsource: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.load)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(xmlsource), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.load)(::windows_core::Interface::as_raw(self), xmlsource.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn readyState(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6071,10 +5903,11 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.loadXML)(::windows_core::Interface::as_raw(self), bstrxml.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn save(&self, destination: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(destination)).ok() + pub unsafe fn save(&self, destination: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.save)(::windows_core::Interface::as_raw(self), destination.into_param().abi()).ok() } pub unsafe fn validateOnParse(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6106,20 +5939,23 @@ impl IXMLDOMDocument3 { { (::windows_core::Interface::vtable(self).base__.base__.SetpreserveWhiteSpace)(::windows_core::Interface::as_raw(self), ispreserving.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setonreadystatechange(&self, readystatechangesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Setonreadystatechange)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(readystatechangesink)).ok() + pub unsafe fn Setonreadystatechange(&self, readystatechangesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Setonreadystatechange)(::windows_core::Interface::as_raw(self), readystatechangesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setondataavailable(&self, ondataavailablesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Setondataavailable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ondataavailablesink)).ok() + pub unsafe fn Setondataavailable(&self, ondataavailablesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Setondataavailable)(::windows_core::Interface::as_raw(self), ondataavailablesink.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setontransformnode(&self, ontransformnodesink: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Setontransformnode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ontransformnodesink)).ok() + pub unsafe fn Setontransformnode(&self, ontransformnodesink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Setontransformnode)(::windows_core::Interface::as_raw(self), ontransformnodesink.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6127,16 +5963,15 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.namespaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn schemas(&self) -> ::windows_core::Result { + pub unsafe fn schemas(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.schemas)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn putref_schemas(&self, othercollection: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.putref_schemas)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(othercollection)).ok() + pub unsafe fn putref_schemas(&self, othercollection: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.putref_schemas)(::windows_core::Interface::as_raw(self), othercollection.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6144,17 +5979,14 @@ impl IXMLDOMDocument3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.validate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setProperty(&self, name: P0, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setProperty(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).base__.setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -6210,16 +6042,15 @@ impl IXMLDOMDocumentFragment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6267,14 +6098,15 @@ impl IXMLDOMDocumentFragment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6347,20 +6179,17 @@ impl IXMLDOMDocumentFragment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6417,13 +6246,14 @@ impl IXMLDOMDocumentFragment { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6447,16 +6277,15 @@ impl IXMLDOMDocumentType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6504,14 +6333,15 @@ impl IXMLDOMDocumentType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6584,20 +6414,17 @@ impl IXMLDOMDocumentType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6654,13 +6481,14 @@ impl IXMLDOMDocumentType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6709,16 +6537,15 @@ impl IXMLDOMElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6766,14 +6593,15 @@ impl IXMLDOMElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6846,20 +6674,17 @@ impl IXMLDOMElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6916,34 +6741,32 @@ impl IXMLDOMElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn tagName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).tagName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttribute(&self, name: P0, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setAttribute(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } pub unsafe fn removeAttribute(&self, name: P0) -> ::windows_core::Result<()> where @@ -6997,14 +6820,8 @@ impl IXMLDOMElement { pub struct IXMLDOMElement_Vtbl { pub base__: IXMLDOMNode_Vtbl, pub tagName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tagname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getAttribute: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttribute: usize, + pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub getAttributeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, attributenode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7039,16 +6856,15 @@ impl IXMLDOMEntity { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7096,14 +6912,15 @@ impl IXMLDOMEntity { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7176,20 +6993,17 @@ impl IXMLDOMEntity { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7246,23 +7060,20 @@ impl IXMLDOMEntity { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn publicId(&self) -> ::windows_core::Result { + pub unsafe fn publicId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).publicId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn systemId(&self) -> ::windows_core::Result { + pub unsafe fn systemId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).systemId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7276,14 +7087,8 @@ impl IXMLDOMEntity { #[doc(hidden)] pub struct IXMLDOMEntity_Vtbl { pub base__: IXMLDOMNode_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub publicId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, publicid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - publicId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub systemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, systemid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - systemId: usize, + pub publicId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, publicid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub systemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, systemid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub notationName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -7301,16 +7106,15 @@ impl IXMLDOMEntityReference { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7358,14 +7162,15 @@ impl IXMLDOMEntityReference { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7438,20 +7243,17 @@ impl IXMLDOMEntityReference { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7508,13 +7310,14 @@ impl IXMLDOMEntityReference { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -7684,16 +7487,15 @@ impl IXMLDOMNode { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7741,14 +7543,15 @@ impl IXMLDOMNode { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7821,20 +7624,17 @@ impl IXMLDOMNode { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7891,13 +7691,14 @@ impl IXMLDOMNode { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -7906,14 +7707,8 @@ impl IXMLDOMNode { pub struct IXMLDOMNode_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub nodeName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub nodeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - nodeValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetnodeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetnodeValue: usize, + pub nodeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetnodeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub nodeType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut DOMNodeType) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub parentNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, parent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7943,9 +7738,9 @@ pub struct IXMLDOMNode_Vtbl { pub attributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributemap: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] attributes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub insertBefore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newchild: *mut ::core::ffi::c_void, refchild: super::super::super::System::Variant::VARIANT, outnewchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub insertBefore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newchild: *mut ::core::ffi::c_void, refchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, outnewchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] insertBefore: usize, #[cfg(feature = "Win32_System_Com")] pub replaceChild: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newchild: *mut ::core::ffi::c_void, oldchild: *mut ::core::ffi::c_void, outoldchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7976,18 +7771,9 @@ pub struct IXMLDOMNode_Vtbl { pub definition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, definitionnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] definition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub nodeTypedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typedvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - nodeTypedValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetnodeTypedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetnodeTypedValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub dataType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, datatypename: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - dataType: usize, + pub nodeTypedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typedvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetnodeTypedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typedvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub dataType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, datatypename: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetdataType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, datatypename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub xml: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, xmlstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -8006,9 +7792,9 @@ pub struct IXMLDOMNode_Vtbl { pub namespaceURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub prefix: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prefixstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub baseName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namestring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub transformNodeToObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, stylesheet: *mut ::core::ffi::c_void, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub transformNodeToObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, stylesheet: *mut ::core::ffi::c_void, outputobject: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] transformNodeToObject: usize, } #[cfg(feature = "Win32_System_Com")] @@ -8078,16 +7864,15 @@ impl IXMLDOMNotation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -8135,14 +7920,15 @@ impl IXMLDOMNotation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -8215,20 +8001,17 @@ impl IXMLDOMNotation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8285,23 +8068,20 @@ impl IXMLDOMNotation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn publicId(&self) -> ::windows_core::Result { + pub unsafe fn publicId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).publicId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn systemId(&self) -> ::windows_core::Result { + pub unsafe fn systemId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).systemId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8311,14 +8091,8 @@ impl IXMLDOMNotation { #[doc(hidden)] pub struct IXMLDOMNotation_Vtbl { pub base__: IXMLDOMNode_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub publicId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, publicid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - publicId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub systemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, systemid: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - systemId: usize, + pub publicId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, publicid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub systemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, systemid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -8511,16 +8285,15 @@ impl IXMLDOMProcessingInstruction { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -8568,14 +8341,15 @@ impl IXMLDOMProcessingInstruction { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -8648,20 +8422,17 @@ impl IXMLDOMProcessingInstruction { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8718,13 +8489,14 @@ impl IXMLDOMProcessingInstruction { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn target(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -8761,13 +8533,12 @@ pub struct IXMLDOMProcessingInstruction_Vtbl { ::windows_core::imp::interface_hierarchy!(IXMLDOMSchemaCollection, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IXMLDOMSchemaCollection { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn add(&self, namespaceuri: P0, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn add(&self, namespaceuri: P0, var: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).add)(::windows_core::Interface::as_raw(self), namespaceuri.into_param().abi(), ::core::mem::transmute(var)).ok() + (::windows_core::Interface::vtable(self).add)(::windows_core::Interface::as_raw(self), namespaceuri.into_param().abi(), var.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -8810,10 +8581,7 @@ impl IXMLDOMSchemaCollection { #[doc(hidden)] pub struct IXMLDOMSchemaCollection_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - add: usize, + pub add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, schemanode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -8838,13 +8606,12 @@ pub struct IXMLDOMSchemaCollection_Vtbl { ::windows_core::imp::interface_hierarchy!(IXMLDOMSchemaCollection2, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch, IXMLDOMSchemaCollection); #[cfg(feature = "Win32_System_Com")] impl IXMLDOMSchemaCollection2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn add(&self, namespaceuri: P0, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn add(&self, namespaceuri: P0, var: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.add)(::windows_core::Interface::as_raw(self), namespaceuri.into_param().abi(), ::core::mem::transmute(var)).ok() + (::windows_core::Interface::vtable(self).base__.add)(::windows_core::Interface::as_raw(self), namespaceuri.into_param().abi(), var.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -9018,22 +8785,19 @@ impl IXMLDOMSelection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).clone)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getProperty(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setProperty(&self, name: P0, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setProperty(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).setProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -9068,14 +8832,8 @@ pub struct IXMLDOMSelection_Vtbl { pub clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] clone: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setProperty: usize, + pub getProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -9092,16 +8850,15 @@ impl IXMLDOMText { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -9149,14 +8906,15 @@ impl IXMLDOMText { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -9229,20 +8987,17 @@ impl IXMLDOMText { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -9299,13 +9054,14 @@ impl IXMLDOMText { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } pub unsafe fn data(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -9489,11 +9245,15 @@ impl IXMLDocument { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).dtdURL)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn createElement(&self, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn createElement(&self, vtype: P0, var1: P1) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).createElement)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtype), ::core::mem::transmute(var1), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).createElement)(::windows_core::Interface::as_raw(self), vtype.into_param().abi(), var1.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -9517,9 +9277,9 @@ pub struct IXMLDocument_Vtbl { pub version: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub doctype: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub dtdURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub createElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub createElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] createElement: usize, } #[cfg(feature = "Win32_System_Com")] @@ -9591,11 +9351,15 @@ impl IXMLDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).dtdURL)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn createElement(&self, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn createElement(&self, vtype: P0, var1: P1) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).createElement)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtype), ::core::mem::transmute(var1), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).createElement)(::windows_core::Interface::as_raw(self), vtype.into_param().abi(), var1.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn r#async(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -9629,9 +9393,9 @@ pub struct IXMLDocument2_Vtbl { pub version: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub doctype: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub dtdURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub createElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtype: super::super::super::System::Variant::VARIANT, var1: super::super::super::System::Variant::VARIANT, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub createElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppelem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] createElement: usize, pub r#async: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pf: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Setasync: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, f: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -9663,17 +9427,14 @@ impl IXMLElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttribute(&self, strpropertyname: P0, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setAttribute(&self, strpropertyname: P0, propertyvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), ::core::mem::transmute(propertyvalue)).ok() + (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertyvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getAttribute(&self, strpropertyname: P0) -> ::windows_core::Result + pub unsafe fn getAttribute(&self, strpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -9734,14 +9495,8 @@ pub struct IXMLElement_Vtbl { pub parent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppparent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] parent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttribute: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getAttribute: usize, + pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub children: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -9786,17 +9541,14 @@ impl IXMLElement2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttribute(&self, strpropertyname: P0, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setAttribute(&self, strpropertyname: P0, propertyvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), ::core::mem::transmute(propertyvalue)).ok() + (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertyvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getAttribute(&self, strpropertyname: P0) -> ::windows_core::Result + pub unsafe fn getAttribute(&self, strpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -9863,14 +9615,8 @@ pub struct IXMLElement2_Vtbl { pub parent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppparent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] parent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttribute: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getAttribute: usize, + pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub children: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -9914,11 +9660,15 @@ impl IXMLElementCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._newEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn item(&self, var1: super::super::super::System::Variant::VARIANT, var2: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn item(&self, var1: P0, var2: P1) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var1), ::core::mem::transmute(var2), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).item)(::windows_core::Interface::as_raw(self), var1.into_param().abi(), var2.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -9929,9 +9679,9 @@ pub struct IXMLElementCollection_Vtbl { pub Setlength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: i32) -> ::windows_core::HRESULT, pub length: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut i32) -> ::windows_core::HRESULT, pub _newEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var1: super::super::super::System::Variant::VARIANT, var2: super::super::super::System::Variant::VARIANT, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, var2: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] item: usize, } ::windows_core::imp::com_interface!(IXMLError, IXMLError_Vtbl, 0x948c5ad3_c58d_11d0_9c0b_00c04fc99c8e); @@ -9958,14 +9708,15 @@ pub struct IXMLError_Vtbl { ::windows_core::imp::interface_hierarchy!(IXMLHTTPRequest, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IXMLHTTPRequest { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: super::super::super::System::Variant::VARIANT, bstruser: super::super::super::System::Variant::VARIANT, bstrpassword: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn open(&self, bstrmethod: P0, bstrurl: P1, varasync: P2, bstruser: P3, bstrpassword: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), ::core::mem::transmute(varasync), ::core::mem::transmute(bstruser), ::core::mem::transmute(bstrpassword)).ok() + (::windows_core::Interface::vtable(self).open)(::windows_core::Interface::as_raw(self), bstrmethod.into_param().abi(), bstrurl.into_param().abi(), varasync.into_param().abi(), bstruser.into_param().abi(), bstrpassword.into_param().abi()).ok() } pub unsafe fn setRequestHeader(&self, bstrheader: P0, bstrvalue: P1) -> ::windows_core::Result<()> where @@ -9985,10 +9736,11 @@ impl IXMLHTTPRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getAllResponseHeaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn send(&self, varbody: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).send)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn send(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).send)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } pub unsafe fn abort(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).abort)(::windows_core::Interface::as_raw(self)).ok() @@ -10011,15 +9763,11 @@ impl IXMLHTTPRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).responseText)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseBody(&self) -> ::windows_core::Result { + pub unsafe fn responseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).responseBody)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn responseStream(&self) -> ::windows_core::Result { + pub unsafe fn responseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).responseStream)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -10041,17 +9789,11 @@ impl IXMLHTTPRequest { #[doc(hidden)] pub struct IXMLHTTPRequest_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmethod: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varasync: super::super::super::System::Variant::VARIANT, bstruser: super::super::super::System::Variant::VARIANT, bstrpassword: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - open: usize, + pub open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmethod: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varasync: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstruser: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub setRequestHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrheader: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub getResponseHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrheader: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub getAllResponseHeaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrheaders: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - send: usize, + pub send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plstatus: *mut i32) -> ::windows_core::HRESULT, pub statusText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrstatus: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -10060,14 +9802,8 @@ pub struct IXMLHTTPRequest_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] responseXML: usize, pub responseText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrbody: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub responseBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - responseBody: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub responseStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - responseStream: usize, + pub responseBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub responseStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub readyState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plstate: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Setonreadystatechange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, preadystatesink: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -10371,14 +10107,13 @@ pub struct IXMLHTTPRequest3Callback_Vtbl { ::windows_core::imp::interface_hierarchy!(IXSLProcessor, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IXSLProcessor { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setinput(&self, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setinput)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var)).ok() + pub unsafe fn Setinput(&self, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setinput)(::windows_core::Interface::as_raw(self), var.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn input(&self) -> ::windows_core::Result { + pub unsafe fn input(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).input)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -10403,14 +10138,13 @@ impl IXSLProcessor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).startModeURI)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Setoutput(&self, output: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Setoutput)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(output)).ok() + pub unsafe fn Setoutput(&self, output: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Setoutput)(::windows_core::Interface::as_raw(self), output.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn output(&self) -> ::windows_core::Result { + pub unsafe fn output(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).output)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -10425,14 +10159,13 @@ impl IXSLProcessor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).readyState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn addParameter(&self, basename: P0, parameter: super::super::super::System::Variant::VARIANT, namespaceuri: P1) -> ::windows_core::Result<()> + pub unsafe fn addParameter(&self, basename: P0, parameter: P1, namespaceuri: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, - P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).addParameter)(::windows_core::Interface::as_raw(self), basename.into_param().abi(), ::core::mem::transmute(parameter), namespaceuri.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).addParameter)(::windows_core::Interface::as_raw(self), basename.into_param().abi(), parameter.into_param().abi(), namespaceuri.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10455,14 +10188,8 @@ impl IXSLProcessor { #[doc(hidden)] pub struct IXSLProcessor_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setinput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setinput: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub input: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - input: usize, + pub Setinput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub input: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub ownerTemplate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pptemplate: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -10470,21 +10197,12 @@ pub struct IXSLProcessor_Vtbl { pub setStartMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mode: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub startMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mode: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub startModeURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespaceuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Setoutput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, output: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Setoutput: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub output: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, poutput: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - output: usize, + pub Setoutput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, output: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub output: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, poutput: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub transform: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdone: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub readyState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, preadystate: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub addParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, basename: ::std::mem::MaybeUninit<::windows_core::BSTR>, parameter: super::super::super::System::Variant::VARIANT, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - addParameter: usize, + pub addParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, basename: ::std::mem::MaybeUninit<::windows_core::BSTR>, parameter: ::std::mem::MaybeUninit<::windows_core::VARIANT>, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub addObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, obj: *mut ::core::ffi::c_void, namespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -10559,16 +10277,15 @@ impl IXTLRuntime { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeValue(&self, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetnodeValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn nodeType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -10616,14 +10333,15 @@ impl IXTLRuntime { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn insertBefore(&self, newchild: P0, refchild: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn insertBefore(&self, newchild: P0, refchild: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), ::core::mem::transmute(refchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.insertBefore)(::windows_core::Interface::as_raw(self), newchild.into_param().abi(), refchild.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10696,20 +10414,17 @@ impl IXTLRuntime { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.definition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result { + pub unsafe fn nodeTypedValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.nodeTypedValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetnodeTypedValue(&self, typedvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(typedvalue)).ok() + pub unsafe fn SetnodeTypedValue(&self, typedvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetnodeTypedValue)(::windows_core::Interface::as_raw(self), typedvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn dataType(&self) -> ::windows_core::Result { + pub unsafe fn dataType(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.dataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -10766,13 +10481,14 @@ impl IXTLRuntime { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.baseName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn transformNodeToObject(&self, stylesheet: P0, outputobject: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), ::core::mem::transmute(outputobject)).ok() + (::windows_core::Interface::vtable(self).base__.transformNodeToObject)(::windows_core::Interface::as_raw(self), stylesheet.into_param().abi(), outputobject.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10834,23 +10550,23 @@ impl IXTLRuntime { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).formatNumber)(::windows_core::Interface::as_raw(self), dblnumber, bstrformat.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn formatDate(&self, vardate: super::super::super::System::Variant::VARIANT, bstrformat: P0, vardestlocale: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> + pub unsafe fn formatDate(&self, vardate: P0, bstrformat: P1, vardestlocale: P2) -> ::windows_core::Result<::windows_core::BSTR> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).formatDate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardate), bstrformat.into_param().abi(), ::core::mem::transmute(vardestlocale), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).formatDate)(::windows_core::Interface::as_raw(self), vardate.into_param().abi(), bstrformat.into_param().abi(), vardestlocale.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn formatTime(&self, vartime: super::super::super::System::Variant::VARIANT, bstrformat: P0, vardestlocale: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> + pub unsafe fn formatTime(&self, vartime: P0, bstrformat: P1, vardestlocale: P2) -> ::windows_core::Result<::windows_core::BSTR> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).formatTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartime), bstrformat.into_param().abi(), ::core::mem::transmute(vardestlocale), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).formatTime)(::windows_core::Interface::as_raw(self), vartime.into_param().abi(), bstrformat.into_param().abi(), vardestlocale.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -10880,14 +10596,8 @@ pub struct IXTLRuntime_Vtbl { absoluteChildNumber: usize, pub formatIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub formatNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dblnumber: f64, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub formatDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardate: super::super::super::System::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: super::super::super::System::Variant::VARIANT, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - formatDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub formatTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartime: super::super::super::System::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: super::super::super::System::Variant::VARIANT, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - formatTime: usize, + pub formatDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardate: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub formatTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, vardestlocale: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrformattedstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/impl.rs index 1833c59800..81310fc3f8 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/impl.rs @@ -48,8 +48,8 @@ impl IUPnPAsyncResult_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPDescriptionDocument_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn ReadyState(&self) -> ::windows_core::Result; fn Load(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -59,9 +59,9 @@ pub trait IUPnPDescriptionDocument_Impl: Sized + super::super::super::System::Co fn RootDevice(&self) -> ::windows_core::Result; fn DeviceByUDN(&self, bstrudn: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPDescriptionDocument {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPDescriptionDocument_Vtbl { pub const fn new, Impl: IUPnPDescriptionDocument_Impl, const OFFSET: isize>() -> IUPnPDescriptionDocument_Vtbl { unsafe extern "system" fn ReadyState, Impl: IUPnPDescriptionDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plreadystate: *mut i32) -> ::windows_core::HRESULT { @@ -155,8 +155,8 @@ impl IUPnPDescriptionDocumentCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPDevice_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn IsRootDevice(&self) -> ::windows_core::Result; fn RootDevice(&self) -> ::windows_core::Result; @@ -178,9 +178,9 @@ pub trait IUPnPDevice_Impl: Sized + super::super::super::System::Com::IDispatch_ fn IconURL(&self, bstrencodingformat: &::windows_core::BSTR, lsizex: i32, lsizey: i32, lbitdepth: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn Services(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPDevice_Vtbl { pub const fn new, Impl: IUPnPDevice_Impl, const OFFSET: isize>() -> IUPnPDevice_Vtbl { unsafe extern "system" fn IsRootDevice, Impl: IUPnPDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarb: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -528,8 +528,8 @@ impl IUPnPDeviceDocumentAccessEx_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPDeviceFinder_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn FindByType(&self, bstrtypeuri: &::windows_core::BSTR, dwflags: u32) -> ::windows_core::Result; fn CreateAsyncFind(&self, bstrtypeuri: &::windows_core::BSTR, dwflags: u32, punkdevicefindercallback: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result; @@ -537,9 +537,9 @@ pub trait IUPnPDeviceFinder_Impl: Sized + super::super::super::System::Com::IDis fn CancelAsyncFind(&self, lfinddata: i32) -> ::windows_core::Result<()>; fn FindByUDN(&self, bstrudn: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPDeviceFinder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPDeviceFinder_Vtbl { pub const fn new, Impl: IUPnPDeviceFinder_Impl, const OFFSET: isize>() -> IUPnPDeviceFinder_Vtbl { unsafe extern "system" fn FindByType, Impl: IUPnPDeviceFinder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtypeuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: u32, pdevices: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -680,16 +680,16 @@ impl IUPnPDeviceProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPDevices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, bstrudn: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPDevices_Vtbl { pub const fn new, Impl: IUPnPDevices_Impl, const OFFSET: isize>() -> IUPnPDevices_Vtbl { unsafe extern "system" fn Count, Impl: IUPnPDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -736,15 +736,11 @@ impl IUPnPDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUPnPEventSink_Impl: Sized { fn OnStateChanged(&self, cchanges: u32, rgdispidchanges: *const i32) -> ::windows_core::Result<()>; - fn OnStateChangedSafe(&self, varsadispidchanges: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OnStateChangedSafe(&self, varsadispidchanges: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUPnPEventSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUPnPEventSink_Vtbl { pub const fn new, Impl: IUPnPEventSink_Impl, const OFFSET: isize>() -> IUPnPEventSink_Vtbl { unsafe extern "system" fn OnStateChanged, Impl: IUPnPEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cchanges: u32, rgdispidchanges: *const i32) -> ::windows_core::HRESULT { @@ -752,7 +748,7 @@ impl IUPnPEventSink_Vtbl { let this = (*this).get_impl(); this.OnStateChanged(::core::mem::transmute_copy(&cchanges), ::core::mem::transmute_copy(&rgdispidchanges)).into() } - unsafe extern "system" fn OnStateChangedSafe, Impl: IUPnPEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsadispidchanges: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnStateChangedSafe, Impl: IUPnPEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsadispidchanges: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnStateChangedSafe(::core::mem::transmute(&varsadispidchanges)).into() @@ -963,22 +959,22 @@ impl IUPnPReregistrar_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPService_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn QueryStateVariable(&self, bstrvariablename: &::windows_core::BSTR) -> ::windows_core::Result; - fn InvokeAction(&self, bstractionname: &::windows_core::BSTR, vinactionargs: &super::super::super::System::Variant::VARIANT, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn QueryStateVariable(&self, bstrvariablename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn InvokeAction(&self, bstractionname: &::windows_core::BSTR, vinactionargs: &::windows_core::VARIANT, pvoutactionargs: *mut ::windows_core::VARIANT, pvretval: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ServiceTypeIdentifier(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn AddCallback(&self, punkcallback: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LastTransportStatus(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPService_Vtbl { pub const fn new, Impl: IUPnPService_Impl, const OFFSET: isize>() -> IUPnPService_Vtbl { - unsafe extern "system" fn QueryStateVariable, Impl: IUPnPService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrvariablename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QueryStateVariable, Impl: IUPnPService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrvariablename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.QueryStateVariable(::core::mem::transmute(&bstrvariablename)) { @@ -989,7 +985,7 @@ impl IUPnPService_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn InvokeAction, Impl: IUPnPService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: super::super::super::System::Variant::VARIANT, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeAction, Impl: IUPnPService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvoutactionargs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeAction(::core::mem::transmute(&bstractionname), ::core::mem::transmute(&vinactionargs), ::core::mem::transmute_copy(&pvoutactionargs), ::core::mem::transmute_copy(&pvretval)).into() @@ -1046,25 +1042,21 @@ impl IUPnPService_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUPnPServiceAsync_Impl: Sized { - fn BeginInvokeAction(&self, bstractionname: &::windows_core::BSTR, vinactionargs: &super::super::super::System::Variant::VARIANT, pasyncresult: ::core::option::Option<&IUPnPAsyncResult>) -> ::windows_core::Result; - fn EndInvokeAction(&self, ullrequestid: u64, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn BeginInvokeAction(&self, bstractionname: &::windows_core::BSTR, vinactionargs: &::windows_core::VARIANT, pasyncresult: ::core::option::Option<&IUPnPAsyncResult>) -> ::windows_core::Result; + fn EndInvokeAction(&self, ullrequestid: u64, pvoutactionargs: *mut ::windows_core::VARIANT, pvretval: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BeginQueryStateVariable(&self, bstrvariablename: &::windows_core::BSTR, pasyncresult: ::core::option::Option<&IUPnPAsyncResult>) -> ::windows_core::Result; - fn EndQueryStateVariable(&self, ullrequestid: u64, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn EndQueryStateVariable(&self, ullrequestid: u64, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BeginSubscribeToEvents(&self, punkcallback: ::core::option::Option<&::windows_core::IUnknown>, pasyncresult: ::core::option::Option<&IUPnPAsyncResult>) -> ::windows_core::Result; fn EndSubscribeToEvents(&self, ullrequestid: u64) -> ::windows_core::Result<()>; fn BeginSCPDDownload(&self, pasyncresult: ::core::option::Option<&IUPnPAsyncResult>) -> ::windows_core::Result; fn EndSCPDDownload(&self, ullrequestid: u64) -> ::windows_core::Result<::windows_core::BSTR>; fn CancelAsyncOperation(&self, ullrequestid: u64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUPnPServiceAsync {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUPnPServiceAsync_Vtbl { pub const fn new, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>() -> IUPnPServiceAsync_Vtbl { - unsafe extern "system" fn BeginInvokeAction, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: super::super::super::System::Variant::VARIANT, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginInvokeAction, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BeginInvokeAction(::core::mem::transmute(&bstractionname), ::core::mem::transmute(&vinactionargs), ::windows_core::from_raw_borrowed(&pasyncresult)) { @@ -1075,7 +1067,7 @@ impl IUPnPServiceAsync_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EndInvokeAction, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EndInvokeAction, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvoutactionargs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EndInvokeAction(::core::mem::transmute_copy(&ullrequestid), ::core::mem::transmute_copy(&pvoutactionargs), ::core::mem::transmute_copy(&pvretval)).into() @@ -1091,7 +1083,7 @@ impl IUPnPServiceAsync_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EndQueryStateVariable, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EndQueryStateVariable, Impl: IUPnPServiceAsync_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EndQueryStateVariable(::core::mem::transmute_copy(&ullrequestid), ::core::mem::transmute_copy(&pvalue)).into() @@ -1156,18 +1148,18 @@ impl IUPnPServiceAsync_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPServiceCallback_Impl: Sized { - fn StateVariableChanged(&self, pus: ::core::option::Option<&IUPnPService>, pcwszstatevarname: &::windows_core::PCWSTR, vavalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn StateVariableChanged(&self, pus: ::core::option::Option<&IUPnPService>, pcwszstatevarname: &::windows_core::PCWSTR, vavalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ServiceInstanceDied(&self, pus: ::core::option::Option<&IUPnPService>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPServiceCallback {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPServiceCallback_Vtbl { pub const fn new, Impl: IUPnPServiceCallback_Impl, const OFFSET: isize>() -> IUPnPServiceCallback_Vtbl { - unsafe extern "system" fn StateVariableChanged, Impl: IUPnPServiceCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pus: *mut ::core::ffi::c_void, pcwszstatevarname: ::windows_core::PCWSTR, vavalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StateVariableChanged, Impl: IUPnPServiceCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pus: *mut ::core::ffi::c_void, pcwszstatevarname: ::windows_core::PCWSTR, vavalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.StateVariableChanged(::windows_core::from_raw_borrowed(&pus), ::core::mem::transmute(&pcwszstatevarname), ::core::mem::transmute(&vavalue)).into() @@ -1243,16 +1235,16 @@ impl IUPnPServiceEnumProperty_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPServices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, bstrserviceid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPServices_Vtbl { pub const fn new, Impl: IUPnPServices_Impl, const OFFSET: isize>() -> IUPnPServices_Vtbl { unsafe extern "system" fn Count, Impl: IUPnPServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/mod.rs index 802ca283be..7b34d5f2be 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Enumeration/Pnp/mod.rs @@ -589,10 +589,11 @@ impl IUPnPEventSink { pub unsafe fn OnStateChanged(&self, rgdispidchanges: &[i32]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).OnStateChanged)(::windows_core::Interface::as_raw(self), rgdispidchanges.len().try_into().unwrap(), ::core::mem::transmute(rgdispidchanges.as_ptr())).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnStateChangedSafe(&self, varsadispidchanges: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnStateChangedSafe)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsadispidchanges)).ok() + pub unsafe fn OnStateChangedSafe(&self, varsadispidchanges: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).OnStateChangedSafe)(::windows_core::Interface::as_raw(self), varsadispidchanges.into_param().abi()).ok() } } #[repr(C)] @@ -600,10 +601,7 @@ impl IUPnPEventSink { pub struct IUPnPEventSink_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub OnStateChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cchanges: u32, rgdispidchanges: *const i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnStateChangedSafe: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsadispidchanges: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnStateChangedSafe: usize, + pub OnStateChangedSafe: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsadispidchanges: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUPnPEventSource, IUPnPEventSource_Vtbl, 0x204810b5_73b2_11d4_bf42_00b0d0118b56); ::windows_core::imp::interface_hierarchy!(IUPnPEventSource, ::windows_core::IUnknown); @@ -786,22 +784,19 @@ pub struct IUPnPReregistrar_Vtbl { ::windows_core::imp::interface_hierarchy!(IUPnPService, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IUPnPService { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QueryStateVariable(&self, bstrvariablename: P0) -> ::windows_core::Result + pub unsafe fn QueryStateVariable(&self, bstrvariablename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QueryStateVariable)(::windows_core::Interface::as_raw(self), bstrvariablename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeAction(&self, bstractionname: P0, vinactionargs: super::super::super::System::Variant::VARIANT, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn InvokeAction(&self, bstractionname: P0, vinactionargs: P1, pvoutactionargs: *mut ::windows_core::VARIANT, pvretval: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).InvokeAction)(::windows_core::Interface::as_raw(self), bstractionname.into_param().abi(), ::core::mem::transmute(vinactionargs), pvoutactionargs, pvretval).ok() + (::windows_core::Interface::vtable(self).InvokeAction)(::windows_core::Interface::as_raw(self), bstractionname.into_param().abi(), vinactionargs.into_param().abi(), ::core::mem::transmute(pvoutactionargs), ::core::mem::transmute(pvretval)).ok() } pub unsafe fn ServiceTypeIdentifier(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -827,14 +822,8 @@ impl IUPnPService { #[doc(hidden)] pub struct IUPnPService_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub QueryStateVariable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrvariablename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - QueryStateVariable: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: super::super::super::System::Variant::VARIANT, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeAction: usize, + pub QueryStateVariable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrvariablename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub InvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvoutactionargs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ServiceTypeIdentifier: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub AddCallback: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkcallback: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -843,20 +832,17 @@ pub struct IUPnPService_Vtbl { ::windows_core::imp::com_interface!(IUPnPServiceAsync, IUPnPServiceAsync_Vtbl, 0x098bdaf5_5ec1_49e7_a260_b3a11dd8680c); ::windows_core::imp::interface_hierarchy!(IUPnPServiceAsync, ::windows_core::IUnknown); impl IUPnPServiceAsync { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginInvokeAction(&self, bstractionname: P0, vinactionargs: super::super::super::System::Variant::VARIANT, pasyncresult: P1) -> ::windows_core::Result + pub unsafe fn BeginInvokeAction(&self, bstractionname: P0, vinactionargs: P1, pasyncresult: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, - P1: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BeginInvokeAction)(::windows_core::Interface::as_raw(self), bstractionname.into_param().abi(), ::core::mem::transmute(vinactionargs), pasyncresult.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BeginInvokeAction)(::windows_core::Interface::as_raw(self), bstractionname.into_param().abi(), vinactionargs.into_param().abi(), pasyncresult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EndInvokeAction(&self, ullrequestid: u64, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EndInvokeAction)(::windows_core::Interface::as_raw(self), ullrequestid, pvoutactionargs, pvretval).ok() + pub unsafe fn EndInvokeAction(&self, ullrequestid: u64, pvoutactionargs: *mut ::windows_core::VARIANT, pvretval: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).EndInvokeAction)(::windows_core::Interface::as_raw(self), ullrequestid, ::core::mem::transmute(pvoutactionargs), ::core::mem::transmute(pvretval)).ok() } pub unsafe fn BeginQueryStateVariable(&self, bstrvariablename: P0, pasyncresult: P1) -> ::windows_core::Result where @@ -866,10 +852,8 @@ impl IUPnPServiceAsync { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BeginQueryStateVariable)(::windows_core::Interface::as_raw(self), bstrvariablename.into_param().abi(), pasyncresult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EndQueryStateVariable(&self, ullrequestid: u64, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EndQueryStateVariable)(::windows_core::Interface::as_raw(self), ullrequestid, pvalue).ok() + pub unsafe fn EndQueryStateVariable(&self, ullrequestid: u64, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).EndQueryStateVariable)(::windows_core::Interface::as_raw(self), ullrequestid, ::core::mem::transmute(pvalue)).ok() } pub unsafe fn BeginSubscribeToEvents(&self, punkcallback: P0, pasyncresult: P1) -> ::windows_core::Result where @@ -901,19 +885,10 @@ impl IUPnPServiceAsync { #[doc(hidden)] pub struct IUPnPServiceAsync_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BeginInvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: super::super::super::System::Variant::VARIANT, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BeginInvokeAction: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EndInvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvoutactionargs: *mut super::super::super::System::Variant::VARIANT, pvretval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EndInvokeAction: usize, + pub BeginInvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstractionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vinactionargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT, + pub EndInvokeAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvoutactionargs: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BeginQueryStateVariable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrvariablename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EndQueryStateVariable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EndQueryStateVariable: usize, + pub EndQueryStateVariable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ullrequestid: u64, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BeginSubscribeToEvents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkcallback: *mut ::core::ffi::c_void, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT, pub EndSubscribeToEvents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ullrequestid: u64) -> ::windows_core::HRESULT, pub BeginSCPDDownload: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pasyncresult: *mut ::core::ffi::c_void, pullrequestid: *mut u64) -> ::windows_core::HRESULT, @@ -923,14 +898,15 @@ pub struct IUPnPServiceAsync_Vtbl { ::windows_core::imp::com_interface!(IUPnPServiceCallback, IUPnPServiceCallback_Vtbl, 0x31fadca9_ab73_464b_b67d_5c1d0f83c8b8); ::windows_core::imp::interface_hierarchy!(IUPnPServiceCallback, ::windows_core::IUnknown); impl IUPnPServiceCallback { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StateVariableChanged(&self, pus: P0, pcwszstatevarname: P1, vavalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn StateVariableChanged(&self, pus: P0, pcwszstatevarname: P1, vavalue: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).StateVariableChanged)(::windows_core::Interface::as_raw(self), pus.into_param().abi(), pcwszstatevarname.into_param().abi(), ::core::mem::transmute(vavalue)).ok() + (::windows_core::Interface::vtable(self).StateVariableChanged)(::windows_core::Interface::as_raw(self), pus.into_param().abi(), pcwszstatevarname.into_param().abi(), vavalue.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -945,9 +921,9 @@ impl IUPnPServiceCallback { #[doc(hidden)] pub struct IUPnPServiceCallback_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StateVariableChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pus: *mut ::core::ffi::c_void, pcwszstatevarname: ::windows_core::PCWSTR, vavalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub StateVariableChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pus: *mut ::core::ffi::c_void, pcwszstatevarname: ::windows_core::PCWSTR, vavalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] StateVariableChanged: usize, #[cfg(feature = "Win32_System_Com")] pub ServiceInstanceDied: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pus: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Fax/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/Fax/impl.rs index 30d619bad1..203ae49d88 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Fax/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Fax/impl.rs @@ -1,14 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccount_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AccountName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Folders(&self) -> ::windows_core::Result; fn ListenToAccountEvents(&self, eventtypes: FAX_ACCOUNT_EVENTS_TYPE_ENUM) -> ::windows_core::Result<()>; fn RegisteredEvents(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccount {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccount_Vtbl { pub const fn new, Impl: IFaxAccount_Impl, const OFFSET: isize>() -> IFaxAccount_Vtbl { unsafe extern "system" fn AccountName, Impl: IFaxAccount_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstraccountname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -61,17 +61,17 @@ impl IFaxAccount_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountFolders_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OutgoingQueue(&self) -> ::windows_core::Result; fn IncomingQueue(&self) -> ::windows_core::Result; fn IncomingArchive(&self) -> ::windows_core::Result; fn OutgoingArchive(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountFolders {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountFolders_Vtbl { pub const fn new, Impl: IFaxAccountFolders_Impl, const OFFSET: isize>() -> IFaxAccountFolders_Vtbl { unsafe extern "system" fn OutgoingQueue, Impl: IFaxAccountFolders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxoutgoingqueue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -130,8 +130,8 @@ impl IFaxAccountFolders_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountIncomingArchive_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SizeLow(&self) -> ::windows_core::Result; fn SizeHigh(&self) -> ::windows_core::Result; @@ -139,9 +139,9 @@ pub trait IFaxAccountIncomingArchive_Impl: Sized + super::super::System::Com::ID fn GetMessages(&self, lprefetchsize: i32) -> ::windows_core::Result; fn GetMessage(&self, bstrmessageid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountIncomingArchive {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountIncomingArchive_Vtbl { pub const fn new, Impl: IFaxAccountIncomingArchive_Impl, const OFFSET: isize>() -> IFaxAccountIncomingArchive_Vtbl { unsafe extern "system" fn SizeLow, Impl: IFaxAccountIncomingArchive_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plsizelow: *mut i32) -> ::windows_core::HRESULT { @@ -206,15 +206,15 @@ impl IFaxAccountIncomingArchive_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountIncomingQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetJobs(&self) -> ::windows_core::Result; fn GetJob(&self, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountIncomingQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountIncomingQueue_Vtbl { pub const fn new, Impl: IFaxAccountIncomingQueue_Impl, const OFFSET: isize>() -> IFaxAccountIncomingQueue_Vtbl { unsafe extern "system" fn GetJobs, Impl: IFaxAccountIncomingQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxincomingjobs: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -249,8 +249,8 @@ impl IFaxAccountIncomingQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountNotify_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnIncomingJobAdded(&self, pfaxaccount: ::core::option::Option<&IFaxAccount>, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn OnIncomingJobRemoved(&self, pfaxaccount: ::core::option::Option<&IFaxAccount>, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -264,9 +264,9 @@ pub trait IFaxAccountNotify_Impl: Sized + super::super::System::Com::IDispatch_I fn OnOutgoingMessageRemoved(&self, pfaxaccount: ::core::option::Option<&IFaxAccount>, bstrmessageid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn OnServerShutDown(&self, pfaxserver: ::core::option::Option<&IFaxServer2>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountNotify {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountNotify_Vtbl { pub const fn new, Impl: IFaxAccountNotify_Impl, const OFFSET: isize>() -> IFaxAccountNotify_Vtbl { unsafe extern "system" fn OnIncomingJobAdded, Impl: IFaxAccountNotify_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxaccount: *mut ::core::ffi::c_void, bstrjobid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -343,8 +343,8 @@ impl IFaxAccountNotify_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountOutgoingArchive_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SizeLow(&self) -> ::windows_core::Result; fn SizeHigh(&self) -> ::windows_core::Result; @@ -352,9 +352,9 @@ pub trait IFaxAccountOutgoingArchive_Impl: Sized + super::super::System::Com::ID fn GetMessages(&self, lprefetchsize: i32) -> ::windows_core::Result; fn GetMessage(&self, bstrmessageid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountOutgoingArchive {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountOutgoingArchive_Vtbl { pub const fn new, Impl: IFaxAccountOutgoingArchive_Impl, const OFFSET: isize>() -> IFaxAccountOutgoingArchive_Vtbl { unsafe extern "system" fn SizeLow, Impl: IFaxAccountOutgoingArchive_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plsizelow: *mut i32) -> ::windows_core::HRESULT { @@ -419,15 +419,15 @@ impl IFaxAccountOutgoingArchive_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountOutgoingQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetJobs(&self) -> ::windows_core::Result; fn GetJob(&self, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountOutgoingQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountOutgoingQueue_Vtbl { pub const fn new, Impl: IFaxAccountOutgoingQueue_Impl, const OFFSET: isize>() -> IFaxAccountOutgoingQueue_Vtbl { unsafe extern "system" fn GetJobs, Impl: IFaxAccountOutgoingQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxoutgoingjobs: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -462,17 +462,17 @@ impl IFaxAccountOutgoingQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccountSet_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetAccounts(&self) -> ::windows_core::Result; fn GetAccount(&self, bstraccountname: &::windows_core::BSTR) -> ::windows_core::Result; fn AddAccount(&self, bstraccountname: &::windows_core::BSTR) -> ::windows_core::Result; fn RemoveAccount(&self, bstraccountname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccountSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccountSet_Vtbl { pub const fn new, Impl: IFaxAccountSet_Impl, const OFFSET: isize>() -> IFaxAccountSet_Vtbl { unsafe extern "system" fn GetAccounts, Impl: IFaxAccountSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppfaxaccounts: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -525,16 +525,16 @@ impl IFaxAccountSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxAccounts_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxAccounts {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxAccounts_Vtbl { pub const fn new, Impl: IFaxAccounts_Impl, const OFFSET: isize>() -> IFaxAccounts_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxAccounts_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -548,7 +548,7 @@ impl IFaxAccounts_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxAccounts_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxaccount: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxAccounts_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxaccount: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -581,8 +581,8 @@ impl IFaxAccounts_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxActivity_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IncomingMessages(&self) -> ::windows_core::Result; fn RoutingMessages(&self) -> ::windows_core::Result; @@ -590,9 +590,9 @@ pub trait IFaxActivity_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn QueuedMessages(&self) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxActivity {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxActivity_Vtbl { pub const fn new, Impl: IFaxActivity_Impl, const OFFSET: isize>() -> IFaxActivity_Vtbl { unsafe extern "system" fn IncomingMessages, Impl: IFaxActivity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plincomingmessages: *mut i32) -> ::windows_core::HRESULT { @@ -657,8 +657,8 @@ impl IFaxActivity_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxActivityLogging_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LogIncoming(&self) -> ::windows_core::Result; fn SetLogIncoming(&self, blogincoming: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -669,9 +669,9 @@ pub trait IFaxActivityLogging_Impl: Sized + super::super::System::Com::IDispatch fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxActivityLogging {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxActivityLogging_Vtbl { pub const fn new, Impl: IFaxActivityLogging_Impl, const OFFSET: isize>() -> IFaxActivityLogging_Vtbl { unsafe extern "system" fn LogIncoming, Impl: IFaxActivityLogging_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pblogincoming: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -748,8 +748,8 @@ impl IFaxActivityLogging_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxConfiguration_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UseArchive(&self) -> ::windows_core::Result; fn SetUseArchive(&self, busearchive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -794,9 +794,9 @@ pub trait IFaxConfiguration_Impl: Sized + super::super::System::Com::IDispatch_I fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxConfiguration {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxConfiguration_Vtbl { pub const fn new, Impl: IFaxConfiguration_Impl, const OFFSET: isize>() -> IFaxConfiguration_Vtbl { unsafe extern "system" fn UseArchive, Impl: IFaxConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbusearchive: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1185,8 +1185,8 @@ impl IFaxConfiguration_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDevice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result; fn DeviceName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1194,7 +1194,7 @@ pub trait IFaxDevice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn PoweredOff(&self) -> ::windows_core::Result; fn ReceivingNow(&self) -> ::windows_core::Result; fn SendingNow(&self) -> ::windows_core::Result; - fn UsedRoutingMethods(&self) -> ::windows_core::Result; + fn UsedRoutingMethods(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SendEnabled(&self) -> ::windows_core::Result; @@ -1209,15 +1209,15 @@ pub trait IFaxDevice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetTSID(&self, bstrtsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; - fn GetExtensionProperty(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result; - fn SetExtensionProperty(&self, bstrguid: &::windows_core::BSTR, vproperty: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetExtensionProperty(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtensionProperty(&self, bstrguid: &::windows_core::BSTR, vproperty: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn UseRoutingMethod(&self, bstrmethodguid: &::windows_core::BSTR, buse: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn RingingNow(&self) -> ::windows_core::Result; fn AnswerCall(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDevice_Vtbl { pub const fn new, Impl: IFaxDevice_Impl, const OFFSET: isize>() -> IFaxDevice_Vtbl { unsafe extern "system" fn Id, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plid: *mut i32) -> ::windows_core::HRESULT { @@ -1286,7 +1286,7 @@ impl IFaxDevice_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn UsedRoutingMethods, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvusedroutingmethods: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UsedRoutingMethods, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvusedroutingmethods: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.UsedRoutingMethods() { @@ -1403,7 +1403,7 @@ impl IFaxDevice_Vtbl { let this = (*this).get_impl(); this.Save().into() } - unsafe extern "system" fn GetExtensionProperty, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetExtensionProperty, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetExtensionProperty(::core::mem::transmute(&bstrguid)) { @@ -1414,7 +1414,7 @@ impl IFaxDevice_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtensionProperty, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtensionProperty, Impl: IFaxDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtensionProperty(::core::mem::transmute(&bstrguid), ::core::mem::transmute(&vproperty)).into() @@ -1474,8 +1474,8 @@ impl IFaxDevice_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDeviceIds_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, lindex: i32) -> ::windows_core::Result; @@ -1484,9 +1484,9 @@ pub trait IFaxDeviceIds_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Remove(&self, lindex: i32) -> ::windows_core::Result<()>; fn SetOrder(&self, ldeviceid: i32, lneworder: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDeviceIds {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDeviceIds_Vtbl { pub const fn new, Impl: IFaxDeviceIds_Impl, const OFFSET: isize>() -> IFaxDeviceIds_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxDeviceIds_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1551,8 +1551,8 @@ impl IFaxDeviceIds_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDeviceProvider_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FriendlyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ImageName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1565,11 +1565,11 @@ pub trait IFaxDeviceProvider_Impl: Sized + super::super::System::Com::IDispatch_ fn Debug(&self) -> ::windows_core::Result; fn Status(&self) -> ::windows_core::Result; fn InitErrorCode(&self) -> ::windows_core::Result; - fn DeviceIds(&self) -> ::windows_core::Result; + fn DeviceIds(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDeviceProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDeviceProvider_Vtbl { pub const fn new, Impl: IFaxDeviceProvider_Impl, const OFFSET: isize>() -> IFaxDeviceProvider_Vtbl { unsafe extern "system" fn FriendlyName, Impl: IFaxDeviceProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrfriendlyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1693,7 +1693,7 @@ impl IFaxDeviceProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeviceIds, Impl: IFaxDeviceProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdeviceids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeviceIds, Impl: IFaxDeviceProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdeviceids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DeviceIds() { @@ -1724,16 +1724,16 @@ impl IFaxDeviceProvider_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDeviceProviders_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDeviceProviders {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDeviceProviders_Vtbl { pub const fn new, Impl: IFaxDeviceProviders_Impl, const OFFSET: isize>() -> IFaxDeviceProviders_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxDeviceProviders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1747,7 +1747,7 @@ impl IFaxDeviceProviders_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxDeviceProviders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxdeviceprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxDeviceProviders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxdeviceprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -1780,17 +1780,17 @@ impl IFaxDeviceProviders_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDevices_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn get_ItemById(&self, lid: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDevices_Vtbl { pub const fn new, Impl: IFaxDevices_Impl, const OFFSET: isize>() -> IFaxDevices_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1804,7 +1804,7 @@ impl IFaxDevices_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxdevice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxdevice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -1849,8 +1849,8 @@ impl IFaxDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDocument_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Body(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetBody(&self, bstrbody: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1882,14 +1882,14 @@ pub trait IFaxDocument_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetPriority(&self, priority: FAX_PRIORITY_TYPE_ENUM) -> ::windows_core::Result<()>; fn TapiConnection(&self) -> ::windows_core::Result; fn putref_TapiConnection(&self, ptapiconnection: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; - fn Submit(&self, bstrfaxservername: &::windows_core::BSTR) -> ::windows_core::Result; - fn ConnectedSubmit(&self, pfaxserver: ::core::option::Option<&IFaxServer>) -> ::windows_core::Result; + fn Submit(&self, bstrfaxservername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ConnectedSubmit(&self, pfaxserver: ::core::option::Option<&IFaxServer>) -> ::windows_core::Result<::windows_core::VARIANT>; fn AttachFaxToReceipt(&self) -> ::windows_core::Result; fn SetAttachFaxToReceipt(&self, battachfax: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDocument {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDocument_Vtbl { pub const fn new, Impl: IFaxDocument_Impl, const OFFSET: isize>() -> IFaxDocument_Vtbl { unsafe extern "system" fn Body, Impl: IFaxDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrbody: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2138,7 +2138,7 @@ impl IFaxDocument_Vtbl { let this = (*this).get_impl(); this.putref_TapiConnection(::windows_core::from_raw_borrowed(&ptapiconnection)).into() } - unsafe extern "system" fn Submit, Impl: IFaxDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IFaxDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Submit(::core::mem::transmute(&bstrfaxservername)) { @@ -2149,7 +2149,7 @@ impl IFaxDocument_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ConnectedSubmit, Impl: IFaxDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ConnectedSubmit, Impl: IFaxDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ConnectedSubmit(::windows_core::from_raw_borrowed(&pfaxserver)) { @@ -2218,18 +2218,18 @@ impl IFaxDocument_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxDocument2_Impl: Sized + IFaxDocument_Impl { fn SubmissionId(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Bodies(&self) -> ::windows_core::Result; - fn SetBodies(&self, vbodies: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit2(&self, bstrfaxservername: &::windows_core::BSTR, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()>; - fn ConnectedSubmit2(&self, pfaxserver: ::core::option::Option<&IFaxServer>, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()>; + fn Bodies(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBodies(&self, vbodies: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit2(&self, bstrfaxservername: &::windows_core::BSTR, pvfaxoutgoingjobids: *mut ::windows_core::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()>; + fn ConnectedSubmit2(&self, pfaxserver: ::core::option::Option<&IFaxServer>, pvfaxoutgoingjobids: *mut ::windows_core::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxDocument2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxDocument2_Vtbl { pub const fn new, Impl: IFaxDocument2_Impl, const OFFSET: isize>() -> IFaxDocument2_Vtbl { unsafe extern "system" fn SubmissionId, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsubmissionid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2243,7 +2243,7 @@ impl IFaxDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Bodies, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbodies: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Bodies, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbodies: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Bodies() { @@ -2254,17 +2254,17 @@ impl IFaxDocument2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBodies, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vbodies: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBodies, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vbodies: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBodies(::core::mem::transmute(&vbodies)).into() } - unsafe extern "system" fn Submit2, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit2, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit2(::core::mem::transmute(&bstrfaxservername), ::core::mem::transmute_copy(&pvfaxoutgoingjobids), ::core::mem::transmute_copy(&plerrorbodyfile)).into() } - unsafe extern "system" fn ConnectedSubmit2, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn ConnectedSubmit2, Impl: IFaxDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ConnectedSubmit2(::windows_core::from_raw_borrowed(&pfaxserver), ::core::mem::transmute_copy(&pvfaxoutgoingjobids), ::core::mem::transmute_copy(&plerrorbodyfile)).into() @@ -2282,8 +2282,8 @@ impl IFaxDocument2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxEventLogging_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn InitEventsLevel(&self) -> ::windows_core::Result; fn SetInitEventsLevel(&self, initeventlevel: FAX_LOG_LEVEL_ENUM) -> ::windows_core::Result<()>; @@ -2296,9 +2296,9 @@ pub trait IFaxEventLogging_Impl: Sized + super::super::System::Com::IDispatch_Im fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxEventLogging {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxEventLogging_Vtbl { pub const fn new, Impl: IFaxEventLogging_Impl, const OFFSET: isize>() -> IFaxEventLogging_Vtbl { unsafe extern "system" fn InitEventsLevel, Impl: IFaxEventLogging_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, piniteventlevel: *mut FAX_LOG_LEVEL_ENUM) -> ::windows_core::HRESULT { @@ -2393,17 +2393,17 @@ impl IFaxEventLogging_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxFolders_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OutgoingQueue(&self) -> ::windows_core::Result; fn IncomingQueue(&self) -> ::windows_core::Result; fn IncomingArchive(&self) -> ::windows_core::Result; fn OutgoingArchive(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxFolders {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxFolders_Vtbl { pub const fn new, Impl: IFaxFolders_Impl, const OFFSET: isize>() -> IFaxFolders_Vtbl { unsafe extern "system" fn OutgoingQueue, Impl: IFaxFolders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxoutgoingqueue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2462,15 +2462,15 @@ impl IFaxFolders_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxInboundRouting_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetExtensions(&self) -> ::windows_core::Result; fn GetMethods(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxInboundRouting {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxInboundRouting_Vtbl { pub const fn new, Impl: IFaxInboundRouting_Impl, const OFFSET: isize>() -> IFaxInboundRouting_Vtbl { unsafe extern "system" fn GetExtensions, Impl: IFaxInboundRouting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxinboundroutingextensions: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2505,8 +2505,8 @@ impl IFaxInboundRouting_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxInboundRoutingExtension_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FriendlyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ImageName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2518,11 +2518,11 @@ pub trait IFaxInboundRoutingExtension_Impl: Sized + super::super::System::Com::I fn Debug(&self) -> ::windows_core::Result; fn Status(&self) -> ::windows_core::Result; fn InitErrorCode(&self) -> ::windows_core::Result; - fn Methods(&self) -> ::windows_core::Result; + fn Methods(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxInboundRoutingExtension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxInboundRoutingExtension_Vtbl { pub const fn new, Impl: IFaxInboundRoutingExtension_Impl, const OFFSET: isize>() -> IFaxInboundRoutingExtension_Vtbl { unsafe extern "system" fn FriendlyName, Impl: IFaxInboundRoutingExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrfriendlyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2635,7 +2635,7 @@ impl IFaxInboundRoutingExtension_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Methods, Impl: IFaxInboundRoutingExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvmethods: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Methods, Impl: IFaxInboundRoutingExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvmethods: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Methods() { @@ -2665,16 +2665,16 @@ impl IFaxInboundRoutingExtension_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxInboundRoutingExtensions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxInboundRoutingExtensions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxInboundRoutingExtensions_Vtbl { pub const fn new, Impl: IFaxInboundRoutingExtensions_Impl, const OFFSET: isize>() -> IFaxInboundRoutingExtensions_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxInboundRoutingExtensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2688,7 +2688,7 @@ impl IFaxInboundRoutingExtensions_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxInboundRoutingExtensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxinboundroutingextension: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxInboundRoutingExtensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxinboundroutingextension: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -2721,8 +2721,8 @@ impl IFaxInboundRoutingExtensions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxInboundRoutingMethod_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GUID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2734,9 +2734,9 @@ pub trait IFaxInboundRoutingMethod_Impl: Sized + super::super::System::Com::IDis fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxInboundRoutingMethod {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxInboundRoutingMethod_Vtbl { pub const fn new, Impl: IFaxInboundRoutingMethod_Impl, const OFFSET: isize>() -> IFaxInboundRoutingMethod_Vtbl { unsafe extern "system" fn Name, Impl: IFaxInboundRoutingMethod_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2837,16 +2837,16 @@ impl IFaxInboundRoutingMethod_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxInboundRoutingMethods_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxInboundRoutingMethods {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxInboundRoutingMethods_Vtbl { pub const fn new, Impl: IFaxInboundRoutingMethods_Impl, const OFFSET: isize>() -> IFaxInboundRoutingMethods_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxInboundRoutingMethods_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2860,7 +2860,7 @@ impl IFaxInboundRoutingMethods_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxInboundRoutingMethods_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxinboundroutingmethod: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxInboundRoutingMethods_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxinboundroutingmethod: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -2893,8 +2893,8 @@ impl IFaxInboundRoutingMethods_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingArchive_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UseArchive(&self) -> ::windows_core::Result; fn SetUseArchive(&self, busearchive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -2915,9 +2915,9 @@ pub trait IFaxIncomingArchive_Impl: Sized + super::super::System::Com::IDispatch fn GetMessages(&self, lprefetchsize: i32) -> ::windows_core::Result; fn GetMessage(&self, bstrmessageid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingArchive {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingArchive_Vtbl { pub const fn new, Impl: IFaxIncomingArchive_Impl, const OFFSET: isize>() -> IFaxIncomingArchive_Vtbl { unsafe extern "system" fn UseArchive, Impl: IFaxIncomingArchive_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbusearchive: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3096,8 +3096,8 @@ impl IFaxIncomingArchive_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingJob_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Size(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3119,9 +3119,9 @@ pub trait IFaxIncomingJob_Impl: Sized + super::super::System::Com::IDispatch_Imp fn Refresh(&self) -> ::windows_core::Result<()>; fn CopyTiff(&self, bstrtiffpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingJob_Vtbl { pub const fn new, Impl: IFaxIncomingJob_Impl, const OFFSET: isize>() -> IFaxIncomingJob_Vtbl { unsafe extern "system" fn Size, Impl: IFaxIncomingJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plsize: *mut i32) -> ::windows_core::HRESULT { @@ -3342,16 +3342,16 @@ impl IFaxIncomingJob_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingJobs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingJobs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingJobs_Vtbl { pub const fn new, Impl: IFaxIncomingJobs_Impl, const OFFSET: isize>() -> IFaxIncomingJobs_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxIncomingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3365,7 +3365,7 @@ impl IFaxIncomingJobs_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxIncomingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxincomingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxIncomingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxincomingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -3398,8 +3398,8 @@ impl IFaxIncomingJobs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingMessage_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Pages(&self) -> ::windows_core::Result; @@ -3415,9 +3415,9 @@ pub trait IFaxIncomingMessage_Impl: Sized + super::super::System::Com::IDispatch fn CopyTiff(&self, bstrtiffpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingMessage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingMessage_Vtbl { pub const fn new, Impl: IFaxIncomingMessage_Impl, const OFFSET: isize>() -> IFaxIncomingMessage_Vtbl { unsafe extern "system" fn Id, Impl: IFaxIncomingMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3572,8 +3572,8 @@ impl IFaxIncomingMessage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingMessage2_Impl: Sized + IFaxIncomingMessage_Impl { fn Subject(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSubject(&self, bstrsubject: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3592,9 +3592,9 @@ pub trait IFaxIncomingMessage2_Impl: Sized + IFaxIncomingMessage_Impl { fn Save(&self) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingMessage2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingMessage2_Vtbl { pub const fn new, Impl: IFaxIncomingMessage2_Impl, const OFFSET: isize>() -> IFaxIncomingMessage2_Vtbl { unsafe extern "system" fn Subject, Impl: IFaxIncomingMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsubject: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3743,8 +3743,8 @@ impl IFaxIncomingMessage2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingMessageIterator_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Message(&self) -> ::windows_core::Result; fn PrefetchSize(&self) -> ::windows_core::Result; @@ -3753,9 +3753,9 @@ pub trait IFaxIncomingMessageIterator_Impl: Sized + super::super::System::Com::I fn MoveFirst(&self) -> ::windows_core::Result<()>; fn MoveNext(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingMessageIterator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingMessageIterator_Vtbl { pub const fn new, Impl: IFaxIncomingMessageIterator_Impl, const OFFSET: isize>() -> IFaxIncomingMessageIterator_Vtbl { unsafe extern "system" fn Message, Impl: IFaxIncomingMessageIterator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxincomingmessage: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3820,8 +3820,8 @@ impl IFaxIncomingMessageIterator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxIncomingQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Blocked(&self) -> ::windows_core::Result; fn SetBlocked(&self, bblocked: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -3830,9 +3830,9 @@ pub trait IFaxIncomingQueue_Impl: Sized + super::super::System::Com::IDispatch_I fn GetJobs(&self) -> ::windows_core::Result; fn GetJob(&self, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxIncomingQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxIncomingQueue_Vtbl { pub const fn new, Impl: IFaxIncomingQueue_Impl, const OFFSET: isize>() -> IFaxIncomingQueue_Vtbl { unsafe extern "system" fn Blocked, Impl: IFaxIncomingQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbblocked: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3897,8 +3897,8 @@ impl IFaxIncomingQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxJobStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Status(&self) -> ::windows_core::Result; fn Pages(&self) -> ::windows_core::Result; @@ -3918,9 +3918,9 @@ pub trait IFaxJobStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl fn CallerId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RoutingInformation(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxJobStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxJobStatus_Vtbl { pub const fn new, Impl: IFaxJobStatus_Impl, const OFFSET: isize>() -> IFaxJobStatus_Vtbl { unsafe extern "system" fn Status, Impl: IFaxJobStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstatus: *mut FAX_JOB_STATUS_ENUM) -> ::windows_core::HRESULT { @@ -4135,15 +4135,15 @@ impl IFaxJobStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxLoggingOptions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EventLogging(&self) -> ::windows_core::Result; fn ActivityLogging(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxLoggingOptions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxLoggingOptions_Vtbl { pub const fn new, Impl: IFaxLoggingOptions_Impl, const OFFSET: isize>() -> IFaxLoggingOptions_Vtbl { unsafe extern "system" fn EventLogging, Impl: IFaxLoggingOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxeventlogging: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4178,15 +4178,15 @@ impl IFaxLoggingOptions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutboundRouting_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetGroups(&self) -> ::windows_core::Result; fn GetRules(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutboundRouting {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutboundRouting_Vtbl { pub const fn new, Impl: IFaxOutboundRouting_Impl, const OFFSET: isize>() -> IFaxOutboundRouting_Vtbl { unsafe extern "system" fn GetGroups, Impl: IFaxOutboundRouting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxoutboundroutinggroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4221,16 +4221,16 @@ impl IFaxOutboundRouting_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutboundRoutingGroup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Status(&self) -> ::windows_core::Result; fn DeviceIds(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutboundRoutingGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutboundRoutingGroup_Vtbl { pub const fn new, Impl: IFaxOutboundRoutingGroup_Impl, const OFFSET: isize>() -> IFaxOutboundRoutingGroup_Vtbl { unsafe extern "system" fn Name, Impl: IFaxOutboundRoutingGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4277,18 +4277,18 @@ impl IFaxOutboundRoutingGroup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutboundRoutingGroups_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn Add(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; - fn Remove(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutboundRoutingGroups {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutboundRoutingGroups_Vtbl { pub const fn new, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>() -> IFaxOutboundRoutingGroups_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4302,7 +4302,7 @@ impl IFaxOutboundRoutingGroups_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxoutboundroutinggroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxoutboundroutinggroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -4335,7 +4335,7 @@ impl IFaxOutboundRoutingGroups_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IFaxOutboundRoutingGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&vindex)).into() @@ -4353,8 +4353,8 @@ impl IFaxOutboundRoutingGroups_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutboundRoutingRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CountryCode(&self) -> ::windows_core::Result; fn AreaCode(&self) -> ::windows_core::Result; @@ -4368,9 +4368,9 @@ pub trait IFaxOutboundRoutingRule_Impl: Sized + super::super::System::Com::IDisp fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutboundRoutingRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutboundRoutingRule_Vtbl { pub const fn new, Impl: IFaxOutboundRoutingRule_Impl, const OFFSET: isize>() -> IFaxOutboundRoutingRule_Vtbl { unsafe extern "system" fn CountryCode, Impl: IFaxOutboundRoutingRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcountrycode: *mut i32) -> ::windows_core::HRESULT { @@ -4483,8 +4483,8 @@ impl IFaxOutboundRoutingRule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutboundRoutingRules_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, lindex: i32) -> ::windows_core::Result; @@ -4494,9 +4494,9 @@ pub trait IFaxOutboundRoutingRules_Impl: Sized + super::super::System::Com::IDis fn Remove(&self, lindex: i32) -> ::windows_core::Result<()>; fn Add(&self, lcountrycode: i32, lareacode: i32, busedevice: super::super::Foundation::VARIANT_BOOL, bstrgroupname: &::windows_core::BSTR, ldeviceid: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutboundRoutingRules {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutboundRoutingRules_Vtbl { pub const fn new, Impl: IFaxOutboundRoutingRules_Impl, const OFFSET: isize>() -> IFaxOutboundRoutingRules_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxOutboundRoutingRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4579,8 +4579,8 @@ impl IFaxOutboundRoutingRules_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingArchive_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UseArchive(&self) -> ::windows_core::Result; fn SetUseArchive(&self, busearchive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -4601,9 +4601,9 @@ pub trait IFaxOutgoingArchive_Impl: Sized + super::super::System::Com::IDispatch fn GetMessages(&self, lprefetchsize: i32) -> ::windows_core::Result; fn GetMessage(&self, bstrmessageid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingArchive {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingArchive_Vtbl { pub const fn new, Impl: IFaxOutgoingArchive_Impl, const OFFSET: isize>() -> IFaxOutgoingArchive_Vtbl { unsafe extern "system" fn UseArchive, Impl: IFaxOutgoingArchive_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbusearchive: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4782,8 +4782,8 @@ impl IFaxOutgoingArchive_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingJob_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Subject(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DocumentName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4817,9 +4817,9 @@ pub trait IFaxOutgoingJob_Impl: Sized + super::super::System::Com::IDispatch_Imp fn Refresh(&self) -> ::windows_core::Result<()>; fn Cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingJob_Vtbl { pub const fn new, Impl: IFaxOutgoingJob_Impl, const OFFSET: isize>() -> IFaxOutgoingJob_Vtbl { unsafe extern "system" fn Subject, Impl: IFaxOutgoingJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsubject: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5166,16 +5166,16 @@ impl IFaxOutgoingJob_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingJob2_Impl: Sized + IFaxOutgoingJob_Impl { fn HasCoverPage(&self) -> ::windows_core::Result; fn ReceiptAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ScheduleType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingJob2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingJob2_Vtbl { pub const fn new, Impl: IFaxOutgoingJob2_Impl, const OFFSET: isize>() -> IFaxOutgoingJob2_Vtbl { unsafe extern "system" fn HasCoverPage, Impl: IFaxOutgoingJob2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbhascoverpage: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5222,16 +5222,16 @@ impl IFaxOutgoingJob2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingJobs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, vindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, vindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingJobs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingJobs_Vtbl { pub const fn new, Impl: IFaxOutgoingJobs_Impl, const OFFSET: isize>() -> IFaxOutgoingJobs_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxOutgoingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5245,7 +5245,7 @@ impl IFaxOutgoingJobs_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFaxOutgoingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxoutgoingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFaxOutgoingJobs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxoutgoingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&vindex)) { @@ -5278,8 +5278,8 @@ impl IFaxOutgoingJobs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingMessage_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SubmissionId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5301,9 +5301,9 @@ pub trait IFaxOutgoingMessage_Impl: Sized + super::super::System::Com::IDispatch fn CopyTiff(&self, bstrtiffpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingMessage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingMessage_Vtbl { pub const fn new, Impl: IFaxOutgoingMessage_Impl, const OFFSET: isize>() -> IFaxOutgoingMessage_Vtbl { unsafe extern "system" fn SubmissionId, Impl: IFaxOutgoingMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsubmissionid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5530,8 +5530,8 @@ impl IFaxOutgoingMessage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingMessage2_Impl: Sized + IFaxOutgoingMessage_Impl { fn HasCoverPage(&self) -> ::windows_core::Result; fn ReceiptType(&self) -> ::windows_core::Result; @@ -5541,9 +5541,9 @@ pub trait IFaxOutgoingMessage2_Impl: Sized + IFaxOutgoingMessage_Impl { fn Save(&self) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingMessage2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingMessage2_Vtbl { pub const fn new, Impl: IFaxOutgoingMessage2_Impl, const OFFSET: isize>() -> IFaxOutgoingMessage2_Vtbl { unsafe extern "system" fn HasCoverPage, Impl: IFaxOutgoingMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbhascoverpage: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5620,8 +5620,8 @@ impl IFaxOutgoingMessage2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingMessageIterator_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Message(&self) -> ::windows_core::Result; fn AtEOF(&self) -> ::windows_core::Result; @@ -5630,9 +5630,9 @@ pub trait IFaxOutgoingMessageIterator_Impl: Sized + super::super::System::Com::I fn MoveFirst(&self) -> ::windows_core::Result<()>; fn MoveNext(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingMessageIterator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingMessageIterator_Vtbl { pub const fn new, Impl: IFaxOutgoingMessageIterator_Impl, const OFFSET: isize>() -> IFaxOutgoingMessageIterator_Vtbl { unsafe extern "system" fn Message, Impl: IFaxOutgoingMessageIterator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxoutgoingmessage: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5697,8 +5697,8 @@ impl IFaxOutgoingMessageIterator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxOutgoingQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Blocked(&self) -> ::windows_core::Result; fn SetBlocked(&self, bblocked: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5725,9 +5725,9 @@ pub trait IFaxOutgoingQueue_Impl: Sized + super::super::System::Com::IDispatch_I fn GetJobs(&self) -> ::windows_core::Result; fn GetJob(&self, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxOutgoingQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxOutgoingQueue_Vtbl { pub const fn new, Impl: IFaxOutgoingQueue_Impl, const OFFSET: isize>() -> IFaxOutgoingQueue_Vtbl { unsafe extern "system" fn Blocked, Impl: IFaxOutgoingQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbblocked: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5954,8 +5954,8 @@ impl IFaxOutgoingQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxReceiptOptions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AuthenticationType(&self) -> ::windows_core::Result; fn SetAuthenticationType(&self, r#type: FAX_SMTP_AUTHENTICATION_TYPE_ENUM) -> ::windows_core::Result<()>; @@ -5976,9 +5976,9 @@ pub trait IFaxReceiptOptions_Impl: Sized + super::super::System::Com::IDispatch_ fn UseForInboundRouting(&self) -> ::windows_core::Result; fn SetUseForInboundRouting(&self, buseforinboundrouting: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxReceiptOptions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxReceiptOptions_Vtbl { pub const fn new, Impl: IFaxReceiptOptions_Impl, const OFFSET: isize>() -> IFaxReceiptOptions_Vtbl { unsafe extern "system" fn AuthenticationType, Impl: IFaxReceiptOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptype: *mut FAX_SMTP_AUTHENTICATION_TYPE_ENUM) -> ::windows_core::HRESULT { @@ -6145,17 +6145,17 @@ impl IFaxReceiptOptions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxRecipient_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FaxNumber(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFaxNumber(&self, bstrfaxnumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxRecipient {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxRecipient_Vtbl { pub const fn new, Impl: IFaxRecipient_Impl, const OFFSET: isize>() -> IFaxRecipient_Vtbl { unsafe extern "system" fn FaxNumber, Impl: IFaxRecipient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrfaxnumber: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6202,8 +6202,8 @@ impl IFaxRecipient_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxRecipients_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, lindex: i32) -> ::windows_core::Result; @@ -6211,9 +6211,9 @@ pub trait IFaxRecipients_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Add(&self, bstrfaxnumber: &::windows_core::BSTR, bstrrecipientname: &::windows_core::BSTR) -> ::windows_core::Result; fn Remove(&self, lindex: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxRecipients {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxRecipients_Vtbl { pub const fn new, Impl: IFaxRecipients_Impl, const OFFSET: isize>() -> IFaxRecipients_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFaxRecipients_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6278,23 +6278,23 @@ impl IFaxRecipients_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxSecurity_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn Descriptor(&self) -> ::windows_core::Result; - fn SetDescriptor(&self, vdescriptor: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Descriptor(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDescriptor(&self, vdescriptor: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GrantedRights(&self) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; fn InformationType(&self) -> ::windows_core::Result; fn SetInformationType(&self, linformationtype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxSecurity {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxSecurity_Vtbl { pub const fn new, Impl: IFaxSecurity_Impl, const OFFSET: isize>() -> IFaxSecurity_Vtbl { - unsafe extern "system" fn Descriptor, Impl: IFaxSecurity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdescriptor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Descriptor, Impl: IFaxSecurity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdescriptor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Descriptor() { @@ -6305,7 +6305,7 @@ impl IFaxSecurity_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDescriptor, Impl: IFaxSecurity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDescriptor, Impl: IFaxSecurity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdescriptor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDescriptor(::core::mem::transmute(&vdescriptor)).into() @@ -6362,23 +6362,23 @@ impl IFaxSecurity_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxSecurity2_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn Descriptor(&self) -> ::windows_core::Result; - fn SetDescriptor(&self, vdescriptor: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Descriptor(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDescriptor(&self, vdescriptor: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GrantedRights(&self) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; fn InformationType(&self) -> ::windows_core::Result; fn SetInformationType(&self, linformationtype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxSecurity2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxSecurity2_Vtbl { pub const fn new, Impl: IFaxSecurity2_Impl, const OFFSET: isize>() -> IFaxSecurity2_Vtbl { - unsafe extern "system" fn Descriptor, Impl: IFaxSecurity2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdescriptor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Descriptor, Impl: IFaxSecurity2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdescriptor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Descriptor() { @@ -6389,7 +6389,7 @@ impl IFaxSecurity2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDescriptor, Impl: IFaxSecurity2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDescriptor, Impl: IFaxSecurity2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdescriptor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDescriptor(::core::mem::transmute(&vdescriptor)).into() @@ -6446,8 +6446,8 @@ impl IFaxSecurity2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxSender_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn BillingCode(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetBillingCode(&self, bstrbillingcode: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -6484,9 +6484,9 @@ pub trait IFaxSender_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LoadDefaultSender(&self) -> ::windows_core::Result<()>; fn SaveDefaultSender(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxSender {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxSender_Vtbl { pub const fn new, Impl: IFaxSender_Impl, const OFFSET: isize>() -> IFaxSender_Vtbl { unsafe extern "system" fn BillingCode, Impl: IFaxSender_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrbillingcode: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6797,8 +6797,8 @@ impl IFaxSender_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxServer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Connect(&self, bstrservername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ServerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6817,19 +6817,19 @@ pub trait IFaxServer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ReceiptOptions(&self) -> ::windows_core::Result; fn Security(&self) -> ::windows_core::Result; fn Disconnect(&self) -> ::windows_core::Result<()>; - fn GetExtensionProperty(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result; - fn SetExtensionProperty(&self, bstrguid: &::windows_core::BSTR, vproperty: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetExtensionProperty(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtensionProperty(&self, bstrguid: &::windows_core::BSTR, vproperty: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ListenToServerEvents(&self, eventtypes: FAX_SERVER_EVENTS_TYPE_ENUM) -> ::windows_core::Result<()>; fn RegisterDeviceProvider(&self, bstrguid: &::windows_core::BSTR, bstrfriendlyname: &::windows_core::BSTR, bstrimagename: &::windows_core::BSTR, tspname: &::windows_core::BSTR, lfspiversion: i32) -> ::windows_core::Result<()>; fn UnregisterDeviceProvider(&self, bstruniquename: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn RegisterInboundRoutingExtension(&self, bstrextensionname: &::windows_core::BSTR, bstrfriendlyname: &::windows_core::BSTR, bstrimagename: &::windows_core::BSTR, vmethods: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RegisterInboundRoutingExtension(&self, bstrextensionname: &::windows_core::BSTR, bstrfriendlyname: &::windows_core::BSTR, bstrimagename: &::windows_core::BSTR, vmethods: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn UnregisterInboundRoutingExtension(&self, bstrextensionuniquename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RegisteredEvents(&self) -> ::windows_core::Result; fn APIVersion(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxServer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxServer_Vtbl { pub const fn new, Impl: IFaxServer_Impl, const OFFSET: isize>() -> IFaxServer_Vtbl { unsafe extern "system" fn Connect, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7007,7 +7007,7 @@ impl IFaxServer_Vtbl { let this = (*this).get_impl(); this.Disconnect().into() } - unsafe extern "system" fn GetExtensionProperty, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetExtensionProperty, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetExtensionProperty(::core::mem::transmute(&bstrguid)) { @@ -7018,7 +7018,7 @@ impl IFaxServer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtensionProperty, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtensionProperty, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtensionProperty(::core::mem::transmute(&bstrguid), ::core::mem::transmute(&vproperty)).into() @@ -7038,7 +7038,7 @@ impl IFaxServer_Vtbl { let this = (*this).get_impl(); this.UnregisterDeviceProvider(::core::mem::transmute(&bstruniquename)).into() } - unsafe extern "system" fn RegisterInboundRoutingExtension, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrimagename: ::std::mem::MaybeUninit<::windows_core::BSTR>, vmethods: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterInboundRoutingExtension, Impl: IFaxServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrimagename: ::std::mem::MaybeUninit<::windows_core::BSTR>, vmethods: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RegisterInboundRoutingExtension(::core::mem::transmute(&bstrextensionname), ::core::mem::transmute(&bstrfriendlyname), ::core::mem::transmute(&bstrimagename), ::core::mem::transmute(&vmethods)).into() @@ -7104,17 +7104,17 @@ impl IFaxServer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxServer2_Impl: Sized + IFaxServer_Impl { fn Configuration(&self) -> ::windows_core::Result; fn CurrentAccount(&self) -> ::windows_core::Result; fn FaxAccountSet(&self) -> ::windows_core::Result; fn Security2(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxServer2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxServer2_Vtbl { pub const fn new, Impl: IFaxServer2_Impl, const OFFSET: isize>() -> IFaxServer2_Vtbl { unsafe extern "system" fn Configuration, Impl: IFaxServer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppfaxconfiguration: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7173,12 +7173,12 @@ impl IFaxServer2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxServerNotify_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxServerNotify {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxServerNotify_Vtbl { pub const fn new, Impl: IFaxServerNotify_Impl, const OFFSET: isize>() -> IFaxServerNotify_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7187,8 +7187,8 @@ impl IFaxServerNotify_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFaxServerNotify2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnIncomingJobAdded(&self, pfaxserver: ::core::option::Option<&IFaxServer2>, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn OnIncomingJobRemoved(&self, pfaxserver: ::core::option::Option<&IFaxServer2>, bstrjobid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -7217,9 +7217,9 @@ pub trait IFaxServerNotify2_Impl: Sized + super::super::System::Com::IDispatch_I fn OnDeviceStatusChange(&self, pfaxserver: ::core::option::Option<&IFaxServer2>, ldeviceid: i32, bpoweredoff: super::super::Foundation::VARIANT_BOOL, bsending: super::super::Foundation::VARIANT_BOOL, breceiving: super::super::Foundation::VARIANT_BOOL, bringing: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn OnGeneralServerConfigChanged(&self, pfaxserver: ::core::option::Option<&IFaxServer2>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFaxServerNotify2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFaxServerNotify2_Vtbl { pub const fn new, Impl: IFaxServerNotify2_Impl, const OFFSET: isize>() -> IFaxServerNotify2_Vtbl { unsafe extern "system" fn OnIncomingJobAdded, Impl: IFaxServerNotify2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, bstrjobid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Fax/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/Fax/mod.rs index 666e9b1e3a..5f1763ec5a 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Fax/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Fax/mod.rs @@ -1013,11 +1013,14 @@ impl IFaxAccounts { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1030,9 +1033,9 @@ impl IFaxAccounts { pub struct IFaxAccounts_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxaccount: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxaccount: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -1415,9 +1418,7 @@ impl IFaxDevice { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SendingNow)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UsedRoutingMethods(&self) -> ::windows_core::Result { + pub unsafe fn UsedRoutingMethods(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).UsedRoutingMethods)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1481,22 +1482,19 @@ impl IFaxDevice { pub unsafe fn Save(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result + pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), ::core::mem::transmute(vproperty)).ok() + (::windows_core::Interface::vtable(self).SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), vproperty.into_param().abi()).ok() } pub unsafe fn UseRoutingMethod(&self, bstrmethodguid: P0, buse: P1) -> ::windows_core::Result<()> where @@ -1524,10 +1522,7 @@ pub struct IFaxDevice_Vtbl { pub PoweredOff: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbpoweredoff: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub ReceivingNow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbreceivingnow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SendingNow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbsendingnow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UsedRoutingMethods: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvusedroutingmethods: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UsedRoutingMethods: usize, + pub UsedRoutingMethods: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvusedroutingmethods: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SendEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbsendenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -1542,14 +1537,8 @@ pub struct IFaxDevice_Vtbl { pub SetTSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtsid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetExtensionProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtensionProperty: usize, + pub GetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub UseRoutingMethod: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmethodguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, buse: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub RingingNow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbringingnow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub AnswerCall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1654,9 +1643,7 @@ impl IFaxDeviceProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).InitErrorCode)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeviceIds(&self) -> ::windows_core::Result { + pub unsafe fn DeviceIds(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DeviceIds)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1677,10 +1664,7 @@ pub struct IFaxDeviceProvider_Vtbl { pub Debug: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbdebug: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstatus: *mut FAX_PROVIDER_STATUS_ENUM) -> ::windows_core::HRESULT, pub InitErrorCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pliniterrorcode: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeviceIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdeviceids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeviceIds: usize, + pub DeviceIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdeviceids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1697,11 +1681,14 @@ impl IFaxDeviceProviders { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1714,9 +1701,9 @@ impl IFaxDeviceProviders { pub struct IFaxDeviceProviders_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxdeviceprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxdeviceprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -1735,11 +1722,14 @@ impl IFaxDevices { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1758,9 +1748,9 @@ impl IFaxDevices { pub struct IFaxDevices_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxdevice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxdevice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -1917,18 +1907,16 @@ impl IFaxDocument { { (::windows_core::Interface::vtable(self).putref_TapiConnection)(::windows_core::Interface::as_raw(self), ptapiconnection.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, bstrfaxservername: P0) -> ::windows_core::Result + pub unsafe fn Submit(&self, bstrfaxservername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), bstrfaxservername.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConnectedSubmit(&self, pfaxserver: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ConnectedSubmit(&self, pfaxserver: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -1993,13 +1981,10 @@ pub struct IFaxDocument_Vtbl { pub putref_TapiConnection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptapiconnection: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_TapiConnection: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ConnectedSubmit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ConnectedSubmit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ConnectedSubmit: usize, pub AttachFaxToReceipt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbattachfax: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetAttachFaxToReceipt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, battachfax: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -2153,18 +2138,16 @@ impl IFaxDocument2 { { (::windows_core::Interface::vtable(self).base__.putref_TapiConnection)(::windows_core::Interface::as_raw(self), ptapiconnection.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, bstrfaxservername: P0) -> ::windows_core::Result + pub unsafe fn Submit(&self, bstrfaxservername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), bstrfaxservername.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConnectedSubmit(&self, pfaxserver: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ConnectedSubmit(&self, pfaxserver: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -2185,32 +2168,29 @@ impl IFaxDocument2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SubmissionId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Bodies(&self) -> ::windows_core::Result { + pub unsafe fn Bodies(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Bodies)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBodies(&self, vbodies: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBodies)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vbodies)).ok() + pub unsafe fn SetBodies(&self, vbodies: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBodies)(::windows_core::Interface::as_raw(self), vbodies.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit2(&self, bstrfaxservername: P0, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()> + pub unsafe fn Submit2(&self, bstrfaxservername: P0, pvfaxoutgoingjobids: *mut ::windows_core::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).Submit2)(::windows_core::Interface::as_raw(self), bstrfaxservername.into_param().abi(), pvfaxoutgoingjobids, plerrorbodyfile).ok() + (::windows_core::Interface::vtable(self).Submit2)(::windows_core::Interface::as_raw(self), bstrfaxservername.into_param().abi(), ::core::mem::transmute(pvfaxoutgoingjobids), plerrorbodyfile).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConnectedSubmit2(&self, pfaxserver: P0, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ConnectedSubmit2(&self, pfaxserver: P0, pvfaxoutgoingjobids: *mut ::windows_core::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).ConnectedSubmit2)(::windows_core::Interface::as_raw(self), pfaxserver.into_param().abi(), pvfaxoutgoingjobids, plerrorbodyfile).ok() + (::windows_core::Interface::vtable(self).ConnectedSubmit2)(::windows_core::Interface::as_raw(self), pfaxserver.into_param().abi(), ::core::mem::transmute(pvfaxoutgoingjobids), plerrorbodyfile).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2219,21 +2199,12 @@ impl IFaxDocument2 { pub struct IFaxDocument2_Vtbl { pub base__: IFaxDocument_Vtbl, pub SubmissionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsubmissionid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Bodies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbodies: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Bodies: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBodies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vbodies: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBodies: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ConnectedSubmit2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut super::super::System::Variant::VARIANT, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Bodies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbodies: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBodies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vbodies: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ConnectedSubmit2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfaxserver: *mut ::core::ffi::c_void, pvfaxoutgoingjobids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plerrorbodyfile: *mut i32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ConnectedSubmit2: usize, } #[cfg(feature = "Win32_System_Com")] @@ -2445,9 +2416,7 @@ impl IFaxInboundRoutingExtension { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).InitErrorCode)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Methods(&self) -> ::windows_core::Result { + pub unsafe fn Methods(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Methods)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2467,10 +2436,7 @@ pub struct IFaxInboundRoutingExtension_Vtbl { pub Debug: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbdebug: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstatus: *mut FAX_PROVIDER_STATUS_ENUM) -> ::windows_core::HRESULT, pub InitErrorCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pliniterrorcode: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Methods: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvmethods: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Methods: usize, + pub Methods: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvmethods: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2487,11 +2453,14 @@ impl IFaxInboundRoutingExtensions { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2504,9 +2473,9 @@ impl IFaxInboundRoutingExtensions { pub struct IFaxInboundRoutingExtensions_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxinboundroutingextension: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxinboundroutingextension: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -2585,11 +2554,14 @@ impl IFaxInboundRoutingMethods { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2602,9 +2574,9 @@ impl IFaxInboundRoutingMethods { pub struct IFaxInboundRoutingMethods_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxinboundroutingmethod: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxinboundroutingmethod: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -2858,11 +2830,14 @@ impl IFaxIncomingJobs { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2875,9 +2850,9 @@ impl IFaxIncomingJobs { pub struct IFaxIncomingJobs_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxincomingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxincomingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -3468,11 +3443,14 @@ impl IFaxOutboundRoutingGroups { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3487,10 +3465,11 @@ impl IFaxOutboundRoutingGroups { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex)).ok() + pub unsafe fn Remove(&self, vindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), vindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3499,19 +3478,16 @@ impl IFaxOutboundRoutingGroups { pub struct IFaxOutboundRoutingGroups_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxoutboundroutinggroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxoutboundroutinggroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfaxoutboundroutinggroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4132,11 +4108,14 @@ impl IFaxOutgoingJobs { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, vindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, vindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), vindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4149,9 +4128,9 @@ impl IFaxOutgoingJobs { pub struct IFaxOutgoingJobs_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: super::super::System::Variant::VARIANT, pfaxoutgoingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfaxoutgoingjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, } @@ -4839,16 +4818,15 @@ pub struct IFaxRecipients_Vtbl { ::windows_core::imp::interface_hierarchy!(IFaxSecurity, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IFaxSecurity { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Descriptor(&self) -> ::windows_core::Result { + pub unsafe fn Descriptor(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Descriptor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDescriptor(&self, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdescriptor)).ok() + pub unsafe fn SetDescriptor(&self, vdescriptor: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDescriptor)(::windows_core::Interface::as_raw(self), vdescriptor.into_param().abi()).ok() } pub unsafe fn GrantedRights(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4873,14 +4851,8 @@ impl IFaxSecurity { #[doc(hidden)] pub struct IFaxSecurity_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Descriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdescriptor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Descriptor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDescriptor: usize, + pub Descriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdescriptor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdescriptor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GrantedRights: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pgrantedrights: *mut FAX_ACCESS_RIGHTS_ENUM) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4898,16 +4870,15 @@ pub struct IFaxSecurity_Vtbl { ::windows_core::imp::interface_hierarchy!(IFaxSecurity2, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IFaxSecurity2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Descriptor(&self) -> ::windows_core::Result { + pub unsafe fn Descriptor(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Descriptor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDescriptor(&self, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdescriptor)).ok() + pub unsafe fn SetDescriptor(&self, vdescriptor: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDescriptor)(::windows_core::Interface::as_raw(self), vdescriptor.into_param().abi()).ok() } pub unsafe fn GrantedRights(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4932,14 +4903,8 @@ impl IFaxSecurity2 { #[doc(hidden)] pub struct IFaxSecurity2_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Descriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdescriptor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Descriptor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdescriptor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDescriptor: usize, + pub Descriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdescriptor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdescriptor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GrantedRights: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pgrantedrights: *mut FAX_ACCESS_RIGHTS_ENUM_2) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5262,22 +5227,19 @@ impl IFaxServer { pub unsafe fn Disconnect(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Disconnect)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result + pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), ::core::mem::transmute(vproperty)).ok() + (::windows_core::Interface::vtable(self).SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), vproperty.into_param().abi()).ok() } pub unsafe fn ListenToServerEvents(&self, eventtypes: FAX_SERVER_EVENTS_TYPE_ENUM) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ListenToServerEvents)(::windows_core::Interface::as_raw(self), eventtypes).ok() @@ -5297,15 +5259,14 @@ impl IFaxServer { { (::windows_core::Interface::vtable(self).UnregisterDeviceProvider)(::windows_core::Interface::as_raw(self), bstruniquename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterInboundRoutingExtension(&self, bstrextensionname: P0, bstrfriendlyname: P1, bstrimagename: P2, vmethods: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn RegisterInboundRoutingExtension(&self, bstrextensionname: P0, bstrfriendlyname: P1, bstrimagename: P2, vmethods: P3) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).RegisterInboundRoutingExtension)(::windows_core::Interface::as_raw(self), bstrextensionname.into_param().abi(), bstrfriendlyname.into_param().abi(), bstrimagename.into_param().abi(), ::core::mem::transmute(vmethods)).ok() + (::windows_core::Interface::vtable(self).RegisterInboundRoutingExtension)(::windows_core::Interface::as_raw(self), bstrextensionname.into_param().abi(), bstrfriendlyname.into_param().abi(), bstrimagename.into_param().abi(), vmethods.into_param().abi()).ok() } pub unsafe fn UnregisterInboundRoutingExtension(&self, bstrextensionuniquename: P0) -> ::windows_core::Result<()> where @@ -5371,21 +5332,12 @@ pub struct IFaxServer_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Security: usize, pub Disconnect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetExtensionProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtensionProperty: usize, + pub GetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtensionProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ListenToServerEvents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eventtypes: FAX_SERVER_EVENTS_TYPE_ENUM) -> ::windows_core::HRESULT, pub RegisterDeviceProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrimagename: ::std::mem::MaybeUninit<::windows_core::BSTR>, tspname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lfspiversion: i32) -> ::windows_core::HRESULT, pub UnregisterDeviceProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstruniquename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterInboundRoutingExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrimagename: ::std::mem::MaybeUninit<::windows_core::BSTR>, vmethods: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RegisterInboundRoutingExtension: usize, + pub RegisterInboundRoutingExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrimagename: ::std::mem::MaybeUninit<::windows_core::BSTR>, vmethods: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub UnregisterInboundRoutingExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrextensionuniquename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RegisteredEvents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, peventtypes: *mut FAX_SERVER_EVENTS_TYPE_ENUM) -> ::windows_core::HRESULT, pub APIVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, papiversion: *mut FAX_SERVER_APIVERSION_ENUM) -> ::windows_core::HRESULT, @@ -5488,22 +5440,19 @@ impl IFaxServer2 { pub unsafe fn Disconnect(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Disconnect)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result + pub unsafe fn GetExtensionProperty(&self, bstrguid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetExtensionProperty(&self, bstrguid: P0, vproperty: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), ::core::mem::transmute(vproperty)).ok() + (::windows_core::Interface::vtable(self).base__.SetExtensionProperty)(::windows_core::Interface::as_raw(self), bstrguid.into_param().abi(), vproperty.into_param().abi()).ok() } pub unsafe fn ListenToServerEvents(&self, eventtypes: FAX_SERVER_EVENTS_TYPE_ENUM) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ListenToServerEvents)(::windows_core::Interface::as_raw(self), eventtypes).ok() @@ -5523,15 +5472,14 @@ impl IFaxServer2 { { (::windows_core::Interface::vtable(self).base__.UnregisterDeviceProvider)(::windows_core::Interface::as_raw(self), bstruniquename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterInboundRoutingExtension(&self, bstrextensionname: P0, bstrfriendlyname: P1, bstrimagename: P2, vmethods: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn RegisterInboundRoutingExtension(&self, bstrextensionname: P0, bstrfriendlyname: P1, bstrimagename: P2, vmethods: P3) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.RegisterInboundRoutingExtension)(::windows_core::Interface::as_raw(self), bstrextensionname.into_param().abi(), bstrfriendlyname.into_param().abi(), bstrimagename.into_param().abi(), ::core::mem::transmute(vmethods)).ok() + (::windows_core::Interface::vtable(self).base__.RegisterInboundRoutingExtension)(::windows_core::Interface::as_raw(self), bstrextensionname.into_param().abi(), bstrfriendlyname.into_param().abi(), bstrimagename.into_param().abi(), vmethods.into_param().abi()).ok() } pub unsafe fn UnregisterInboundRoutingExtension(&self, bstrextensionuniquename: P0) -> ::windows_core::Result<()> where diff --git a/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/impl.rs index a919d1767a..dd58239d0c 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/impl.rs @@ -487,16 +487,16 @@ impl IFunctionInstanceCollection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IFunctionInstanceCollectionQuery_Impl: Sized { fn AddQueryConstraint(&self, pszconstraintname: &::windows_core::PCWSTR, pszconstraintvalue: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn AddPropertyConstraint(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::Result<()>; + fn AddPropertyConstraint(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::windows_core::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::Result<()>; fn Execute(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IFunctionInstanceCollectionQuery {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IFunctionInstanceCollectionQuery_Vtbl { pub const fn new, Impl: IFunctionInstanceCollectionQuery_Impl, const OFFSET: isize>() -> IFunctionInstanceCollectionQuery_Vtbl { unsafe extern "system" fn AddQueryConstraint, Impl: IFunctionInstanceCollectionQuery_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszconstraintname: ::windows_core::PCWSTR, pszconstraintvalue: ::windows_core::PCWSTR) -> ::windows_core::HRESULT { @@ -504,7 +504,7 @@ impl IFunctionInstanceCollectionQuery_Vtbl { let this = (*this).get_impl(); this.AddQueryConstraint(::core::mem::transmute(&pszconstraintname), ::core::mem::transmute(&pszconstraintvalue)).into() } - unsafe extern "system" fn AddPropertyConstraint, Impl: IFunctionInstanceCollectionQuery_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyConstraint, Impl: IFunctionInstanceCollectionQuery_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyConstraint(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&pv), ::core::mem::transmute_copy(&enumpropertyconstraint)).into() @@ -710,17 +710,17 @@ impl IPropertyStoreCollection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IProviderProperties_Impl: Sized { fn GetCount(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize) -> ::windows_core::Result; fn GetAt(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<()>; - fn GetValue(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; - fn SetValue(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetValue(&self, pifunctioninstance: ::core::option::Option<&IFunctionInstance>, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IProviderProperties {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IProviderProperties_Vtbl { pub const fn new, Impl: IProviderProperties_Impl, const OFFSET: isize>() -> IProviderProperties_Vtbl { unsafe extern "system" fn GetCount, Impl: IProviderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, pdwcount: *mut u32) -> ::windows_core::HRESULT { @@ -739,7 +739,7 @@ impl IProviderProperties_Vtbl { let this = (*this).get_impl(); this.GetAt(::windows_core::from_raw_borrowed(&pifunctioninstance), ::core::mem::transmute_copy(&iproviderinstancecontext), ::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&pkey)).into() } - unsafe extern "system" fn GetValue, Impl: IProviderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IProviderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::windows_core::from_raw_borrowed(&pifunctioninstance), ::core::mem::transmute_copy(&iproviderinstancecontext), ::core::mem::transmute_copy(&key)) { @@ -750,7 +750,7 @@ impl IProviderProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IProviderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IProviderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::windows_core::from_raw_borrowed(&pifunctioninstance), ::core::mem::transmute_copy(&iproviderinstancecontext), ::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&ppropvar)).into() @@ -767,19 +767,19 @@ impl IProviderProperties_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IProviderPropertyConstraintCollection_Impl: Sized { fn GetCount(&self) -> ::windows_core::Result; - fn Get(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; - fn Item(&self, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; - fn Next(&self, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; + fn Get(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; + fn Item(&self, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IProviderPropertyConstraintCollection {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IProviderPropertyConstraintCollection_Vtbl { pub const fn new, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>() -> IProviderPropertyConstraintCollection_Vtbl { unsafe extern "system" fn GetCount, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT { @@ -793,17 +793,17 @@ impl IProviderPropertyConstraintCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Get, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Get, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Get(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&pdwpropertyconstraint)).into() } - unsafe extern "system" fn Item, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Item(::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&pkey), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&pdwpropertyconstraint)).into() } - unsafe extern "system" fn Next, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IProviderPropertyConstraintCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&pkey), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&pdwpropertyconstraint)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/mod.rs index 82ac5b2fc4..c0a0e2895f 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/FunctionDiscovery/mod.rs @@ -416,10 +416,10 @@ impl IFunctionInstanceCollectionQuery { { (::windows_core::Interface::vtable(self).AddQueryConstraint)(::windows_core::Interface::as_raw(self), pszconstraintname.into_param().abi(), pszconstraintvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn AddPropertyConstraint(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyConstraint)(::windows_core::Interface::as_raw(self), key, pv, enumpropertyconstraint).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn AddPropertyConstraint(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::windows_core::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).AddPropertyConstraint)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(pv), enumpropertyconstraint).ok() } pub unsafe fn Execute(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -431,9 +431,9 @@ impl IFunctionInstanceCollectionQuery { pub struct IFunctionInstanceCollectionQuery_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub AddQueryConstraint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszconstraintname: ::windows_core::PCWSTR, pszconstraintvalue: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub AddPropertyConstraint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub AddPropertyConstraint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, enumpropertyconstraint: PropertyConstraint) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] AddPropertyConstraint: usize, pub Execute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppifunctioninstancecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -605,22 +605,22 @@ impl IProviderProperties { { (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), pifunctioninstance.into_param().abi(), iproviderinstancecontext, dwindex, pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, pifunctioninstance: P0, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn GetValue(&self, pifunctioninstance: P0, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), pifunctioninstance.into_param().abi(), iproviderinstancecontext, key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetValue(&self, pifunctioninstance: P0, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn SetValue(&self, pifunctioninstance: P0, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), pifunctioninstance.into_param().abi(), iproviderinstancecontext, key, ppropvar).ok() + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), pifunctioninstance.into_param().abi(), iproviderinstancecontext, key, ::core::mem::transmute(ppropvar)).ok() } } #[repr(C)] @@ -635,13 +635,13 @@ pub struct IProviderProperties_Vtbl { pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem")))] GetAt: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem")))] GetValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pifunctioninstance: *mut ::core::ffi::c_void, iproviderinstancecontext: isize, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem")))] SetValue: usize, } ::windows_core::imp::com_interface!(IProviderPropertyConstraintCollection, IProviderPropertyConstraintCollection_Vtbl, 0xf4fae42f_5778_4a13_8540_b5fd8c1398dd); @@ -651,20 +651,20 @@ impl IProviderPropertyConstraintCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Get(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), key, ppropvar, pdwpropertyconstraint).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Get(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(ppropvar), pdwpropertyconstraint).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Item(&self, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), dwindex, pkey, ppropvar, pdwpropertyconstraint).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Item(&self, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), dwindex, pkey, ::core::mem::transmute(ppropvar), pdwpropertyconstraint).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Next(&self, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), pkey, ppropvar, pdwpropertyconstraint).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Next(&self, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), pkey, ::core::mem::transmute(ppropvar), pdwpropertyconstraint).ok() } pub unsafe fn Skip(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Skip)(::windows_core::Interface::as_raw(self)).ok() @@ -678,17 +678,17 @@ impl IProviderPropertyConstraintCollection { pub struct IProviderPropertyConstraintCollection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Get: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Item: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdwpropertyconstraint: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Next: usize, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/impl.rs index 3502f8f6fa..c99aebe62b 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ICivicAddressReport_Impl: Sized + ILocationReport_Impl { fn GetAddressLine1(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetAddressLine2(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -9,9 +9,9 @@ pub trait ICivicAddressReport_Impl: Sized + ILocationReport_Impl { fn GetCountryRegion(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetDetailLevel(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ICivicAddressReport {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ICivicAddressReport_Vtbl { pub const fn new, Impl: ICivicAddressReport_Impl, const OFFSET: isize>() -> ICivicAddressReport_Vtbl { unsafe extern "system" fn GetAddressLine1, Impl: ICivicAddressReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstraddress1: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -106,14 +106,14 @@ impl ICivicAddressReport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICivicAddressReportFactory_Impl: Sized + ILocationReportFactory_Impl { fn CivicAddressReport(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICivicAddressReportFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICivicAddressReportFactory_Vtbl { pub const fn new, Impl: ICivicAddressReportFactory_Impl, const OFFSET: isize>() -> ICivicAddressReportFactory_Vtbl { unsafe extern "system" fn CivicAddressReport, Impl: ICivicAddressReportFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -166,8 +166,8 @@ impl IDefaultLocation_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDispCivicAddressReport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AddressLine1(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn AddressLine2(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -178,9 +178,9 @@ pub trait IDispCivicAddressReport_Impl: Sized + super::super::System::Com::IDisp fn DetailLevel(&self) -> ::windows_core::Result; fn Timestamp(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDispCivicAddressReport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDispCivicAddressReport_Vtbl { pub const fn new, Impl: IDispCivicAddressReport_Impl, const OFFSET: isize>() -> IDispCivicAddressReport_Vtbl { unsafe extern "system" fn AddressLine1, Impl: IDispCivicAddressReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddress1: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -287,8 +287,8 @@ impl IDispCivicAddressReport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDispLatLongReport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Latitude(&self) -> ::windows_core::Result; fn Longitude(&self) -> ::windows_core::Result; @@ -297,9 +297,9 @@ pub trait IDispLatLongReport_Impl: Sized + super::super::System::Com::IDispatch_ fn AltitudeError(&self) -> ::windows_core::Result; fn Timestamp(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDispLatLongReport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDispLatLongReport_Vtbl { pub const fn new, Impl: IDispLatLongReport_Impl, const OFFSET: isize>() -> IDispLatLongReport_Vtbl { unsafe extern "system" fn Latitude, Impl: IDispLatLongReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut f64) -> ::windows_core::HRESULT { @@ -382,8 +382,8 @@ impl IDispLatLongReport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ILatLongReport_Impl: Sized + ILocationReport_Impl { fn GetLatitude(&self) -> ::windows_core::Result; fn GetLongitude(&self) -> ::windows_core::Result; @@ -391,9 +391,9 @@ pub trait ILatLongReport_Impl: Sized + ILocationReport_Impl { fn GetAltitude(&self) -> ::windows_core::Result; fn GetAltitudeError(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ILatLongReport {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ILatLongReport_Vtbl { pub const fn new, Impl: ILatLongReport_Impl, const OFFSET: isize>() -> ILatLongReport_Vtbl { unsafe extern "system" fn GetLatitude, Impl: ILatLongReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, platitude: *mut f64) -> ::windows_core::HRESULT { @@ -464,14 +464,14 @@ impl ILatLongReport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILatLongReportFactory_Impl: Sized + ILocationReportFactory_Impl { fn LatLongReport(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILatLongReportFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILatLongReportFactory_Vtbl { pub const fn new, Impl: ILatLongReportFactory_Impl, const OFFSET: isize>() -> ILatLongReportFactory_Vtbl { unsafe extern "system" fn LatLongReport, Impl: ILatLongReportFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -649,16 +649,16 @@ impl ILocationPower_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ILocationReport_Impl: Sized { fn GetSensorID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetTimestamp(&self) -> ::windows_core::Result; - fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ILocationReport {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ILocationReport_Vtbl { pub const fn new, Impl: ILocationReport_Impl, const OFFSET: isize>() -> ILocationReport_Vtbl { unsafe extern "system" fn GetSensorID, Impl: ILocationReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psensorid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -683,7 +683,7 @@ impl ILocationReport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: ILocationReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ILocationReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&pkey)) { @@ -705,8 +705,8 @@ impl ILocationReport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILocationReportFactory_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ListenForReports(&self, requestedreportinterval: u32) -> ::windows_core::Result<()>; fn StopListeningForReports(&self) -> ::windows_core::Result<()>; @@ -717,9 +717,9 @@ pub trait ILocationReportFactory_Impl: Sized + super::super::System::Com::IDispa fn SetDesiredAccuracy(&self, desiredaccuracy: u32) -> ::windows_core::Result<()>; fn RequestPermissions(&self, hwnd: *const u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILocationReportFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILocationReportFactory_Vtbl { pub const fn new, Impl: ILocationReportFactory_Impl, const OFFSET: isize>() -> ILocationReportFactory_Vtbl { unsafe extern "system" fn ListenForReports, Impl: ILocationReportFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, requestedreportinterval: u32) -> ::windows_core::HRESULT { @@ -796,12 +796,12 @@ impl ILocationReportFactory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _ICivicAddressReportFactoryEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _ICivicAddressReportFactoryEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _ICivicAddressReportFactoryEvents_Vtbl { pub const fn new, Impl: _ICivicAddressReportFactoryEvents_Impl, const OFFSET: isize>() -> _ICivicAddressReportFactoryEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -810,12 +810,12 @@ impl _ICivicAddressReportFactoryEvents_Vtbl { iid == &<_ICivicAddressReportFactoryEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _ILatLongReportFactoryEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _ILatLongReportFactoryEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _ILatLongReportFactoryEvents_Vtbl { pub const fn new, Impl: _ILatLongReportFactoryEvents_Impl, const OFFSET: isize>() -> _ILatLongReportFactoryEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/mod.rs index 9a815c7221..4e73157d08 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Geolocation/mod.rs @@ -9,9 +9,9 @@ impl ICivicAddressReport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetTimestamp)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), pkey, &mut result__).from_abi(result__) } @@ -249,9 +249,9 @@ impl ILatLongReport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetTimestamp)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), pkey, &mut result__).from_abi(result__) } @@ -455,9 +455,9 @@ impl ILocationReport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetTimestamp)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), pkey, &mut result__).from_abi(result__) } @@ -468,9 +468,9 @@ pub struct ILocationReport_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetSensorID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psensorid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetTimestamp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcreationtime: *mut super::super::Foundation::SYSTEMTIME) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetValue: usize, } #[cfg(feature = "Win32_System_Com")] diff --git a/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/impl.rs index 6acdd39e82..fd7ce5f80a 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/impl.rs @@ -1638,11 +1638,11 @@ impl IWiaPreview_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IWiaPropertyStorage_Impl: Sized { - fn ReadMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn WriteMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()>; + fn ReadMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn WriteMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const ::windows_core::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()>; fn DeleteMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC) -> ::windows_core::Result<()>; fn ReadPropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn WritePropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const ::windows_core::PCWSTR) -> ::windows_core::Result<()>; @@ -1653,22 +1653,22 @@ pub trait IWiaPropertyStorage_Impl: Sized { fn SetTimes(&self, pctime: *const super::super::Foundation::FILETIME, patime: *const super::super::Foundation::FILETIME, pmtime: *const super::super::Foundation::FILETIME) -> ::windows_core::Result<()>; fn SetClass(&self, clsid: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn Stat(&self, pstatpsstg: *mut super::super::System::Com::StructuredStorage::STATPROPSETSTG) -> ::windows_core::Result<()>; - fn GetPropertyAttributes(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetPropertyAttributes(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetCount(&self) -> ::windows_core::Result; fn GetPropertyStream(&self, pcompatibilityid: *mut ::windows_core::GUID, ppistream: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn SetPropertyStream(&self, pcompatibilityid: *mut ::windows_core::GUID, pistream: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IWiaPropertyStorage {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IWiaPropertyStorage_Vtbl { pub const fn new, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>() -> IWiaPropertyStorage_Vtbl { - unsafe extern "system" fn ReadMultiple, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadMultiple, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ReadMultiple(::core::mem::transmute_copy(&cpspec), ::core::mem::transmute_copy(&rgpspec), ::core::mem::transmute_copy(&rgpropvar)).into() } - unsafe extern "system" fn WriteMultiple, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn WriteMultiple, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propidnamefirst: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WriteMultiple(::core::mem::transmute_copy(&cpspec), ::core::mem::transmute_copy(&rgpspec), ::core::mem::transmute_copy(&rgpropvar), ::core::mem::transmute_copy(&propidnamefirst)).into() @@ -1729,7 +1729,7 @@ impl IWiaPropertyStorage_Vtbl { let this = (*this).get_impl(); this.Stat(::core::mem::transmute_copy(&pstatpsstg)).into() } - unsafe extern "system" fn GetPropertyAttributes, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropertyAttributes, Impl: IWiaPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPropertyAttributes(::core::mem::transmute_copy(&cpspec), ::core::mem::transmute_copy(&rgpspec), ::core::mem::transmute_copy(&rgflags), ::core::mem::transmute_copy(&rgpropvar)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/mod.rs index 5b15a66349..ee2a1c4b5e 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/ImageAcquisition/mod.rs @@ -1018,15 +1018,15 @@ pub struct IWiaPreview_Vtbl { ::windows_core::imp::com_interface!(IWiaPropertyStorage, IWiaPropertyStorage_Vtbl, 0x98b5e8a0_29cc_491a_aac0_e6db4fdcceb6); ::windows_core::imp::interface_hierarchy!(IWiaPropertyStorage, ::windows_core::IUnknown); impl IWiaPropertyStorage { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn ReadMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ReadMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgpropvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn ReadMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ReadMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, ::core::mem::transmute(rgpropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn WriteMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).WriteMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgpropvar, propidnamefirst).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn WriteMultiple(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const ::windows_core::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).WriteMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, ::core::mem::transmute(rgpropvar), propidnamefirst).ok() } #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -1065,10 +1065,10 @@ impl IWiaPropertyStorage { pub unsafe fn Stat(&self, pstatpsstg: *mut super::super::System::Com::StructuredStorage::STATPROPSETSTG) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Stat)(::windows_core::Interface::as_raw(self), pstatpsstg).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyAttributes(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetPropertyAttributes)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgflags, rgpropvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn GetPropertyAttributes(&self, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetPropertyAttributes)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgflags, ::core::mem::transmute(rgpropvar)).ok() } pub unsafe fn GetCount(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1092,13 +1092,13 @@ impl IWiaPropertyStorage { #[doc(hidden)] pub struct IWiaPropertyStorage_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub ReadMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub ReadMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] ReadMultiple: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub WriteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub WriteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgpropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propidnamefirst: u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] WriteMultiple: usize, #[cfg(feature = "Win32_System_Com_StructuredStorage")] pub DeleteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC) -> ::windows_core::HRESULT, @@ -1119,9 +1119,9 @@ pub struct IWiaPropertyStorage_Vtbl { pub Stat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstatpsstg: *mut super::super::System::Com::StructuredStorage::STATPROPSETSTG) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] Stat: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetPropertyAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub GetPropertyAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const super::super::System::Com::StructuredStorage::PROPSPEC, rgflags: *mut u32, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] GetPropertyAttributes: usize, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pulnumprops: *mut u32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] diff --git a/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/impl.rs index c4172c4af9..ba13c182e7 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/impl.rs @@ -838,20 +838,16 @@ impl IPortableDeviceManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPortableDevicePropVariantCollection_Impl: Sized { fn GetCount(&self, pcelems: *const u32) -> ::windows_core::Result<()>; - fn GetAt(&self, dwindex: u32, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn Add(&self, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetAt(&self, dwindex: u32, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn Add(&self, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetType(&self) -> ::windows_core::Result; fn ChangeType(&self, vt: u16) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn RemoveAt(&self, dwindex: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPortableDevicePropVariantCollection {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPortableDevicePropVariantCollection_Vtbl { pub const fn new, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>() -> IPortableDevicePropVariantCollection_Vtbl { unsafe extern "system" fn GetCount, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcelems: *const u32) -> ::windows_core::HRESULT { @@ -859,12 +855,12 @@ impl IPortableDevicePropVariantCollection_Vtbl { let this = (*this).get_impl(); this.GetCount(::core::mem::transmute_copy(&pcelems)).into() } - unsafe extern "system" fn GetAt, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAt, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetAt(::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&pvalue)).into() } - unsafe extern "system" fn Add, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IPortableDevicePropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&pvalue)).into() @@ -1670,13 +1666,13 @@ impl IPortableDeviceUnitsStream_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IPortableDeviceValues_Impl: Sized { fn GetCount(&self, pcelt: *const u32) -> ::windows_core::Result<()>; - fn GetAt(&self, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetAt(&self, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn SetStringValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, value: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetStringValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PWSTR>; fn SetUnsignedIntegerValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, value: u32) -> ::windows_core::Result<()>; @@ -1714,9 +1710,9 @@ pub trait IPortableDeviceValues_Impl: Sized { fn CopyValuesToPropertyStore(&self, pstore: ::core::option::Option<&super::super::UI::Shell::PropertiesSystem::IPropertyStore>) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IPortableDeviceValues {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IPortableDeviceValues_Vtbl { pub const fn new, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>() -> IPortableDeviceValues_Vtbl { unsafe extern "system" fn GetCount, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcelt: *const u32) -> ::windows_core::HRESULT { @@ -1724,17 +1720,17 @@ impl IPortableDeviceValues_Vtbl { let this = (*this).get_impl(); this.GetCount(::core::mem::transmute_copy(&pcelt)).into() } - unsafe extern "system" fn GetAt, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAt, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetAt(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&pkey), ::core::mem::transmute_copy(&pvalue)).into() } - unsafe extern "system" fn SetValue, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&pvalue)).into() } - unsafe extern "system" fn GetValue, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IPortableDeviceValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&key)) { @@ -2111,15 +2107,15 @@ impl IPortableDeviceValuesCollection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPortableDeviceWebControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetDeviceFromId(&self, deviceid: &::windows_core::BSTR) -> ::windows_core::Result; fn GetDeviceFromIdAsync(&self, deviceid: &::windows_core::BSTR, pcompletionhandler: ::core::option::Option<&super::super::System::Com::IDispatch>, perrorhandler: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPortableDeviceWebControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPortableDeviceWebControl_Vtbl { pub const fn new, Impl: IPortableDeviceWebControl_Impl, const OFFSET: isize>() -> IPortableDeviceWebControl_Vtbl { unsafe extern "system" fn GetDeviceFromId, Impl: IPortableDeviceWebControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, deviceid: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppdevice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/mod.rs index 715cbb2b84..7a1d829d0e 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/PortableDevices/mod.rs @@ -697,15 +697,11 @@ impl IPortableDevicePropVariantCollection { pub unsafe fn GetCount(&self, pcelems: *const u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), pcelems).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetAt(&self, dwindex: u32, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), dwindex, pvalue).ok() + pub unsafe fn GetAt(&self, dwindex: u32, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), dwindex, ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pvalue).ok() + pub unsafe fn Add(&self, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn GetType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -726,14 +722,8 @@ impl IPortableDevicePropVariantCollection { pub struct IPortableDevicePropVariantCollection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcelems: *const u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetAt: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Add: usize, + pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvt: *mut u16) -> ::windows_core::HRESULT, pub ChangeType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vt: u16) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1246,19 +1236,19 @@ impl IPortableDeviceValues { pub unsafe fn GetCount(&self, pcelt: *const u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), pcelt).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetAt(&self, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), index, pkey, pvalue).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetAt(&self, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), index, pkey, ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), key, pvalue).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } @@ -1487,17 +1477,17 @@ impl IPortableDeviceValues { pub struct IPortableDeviceValues_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcelt: *const u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetAt: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] SetValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetValue: usize, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub SetStringValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, value: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Sensors/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/Sensors/impl.rs index e2d79c6608..074024cf94 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Sensors/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Sensors/impl.rs @@ -31,14 +31,14 @@ impl ILocationPermissions_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Devices_PortableDevices\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_Devices_PortableDevices\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait ISensor_Impl: Sized { fn GetID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetCategory(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetFriendlyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetProperties(&self, pkeys: ::core::option::Option<&super::PortableDevices::IPortableDeviceKeyCollection>) -> ::windows_core::Result; fn GetSupportedDataFields(&self) -> ::windows_core::Result; fn SetProperties(&self, pproperties: ::core::option::Option<&super::PortableDevices::IPortableDeviceValues>) -> ::windows_core::Result; @@ -50,9 +50,9 @@ pub trait ISensor_Impl: Sized { fn SetEventInterest(&self, pvalues: *const ::windows_core::GUID, count: u32) -> ::windows_core::Result<()>; fn SetEventSink(&self, pevents: ::core::option::Option<&ISensorEvents>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for ISensor {} -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ISensor_Vtbl { pub const fn new, Impl: ISensor_Impl, const OFFSET: isize>() -> ISensor_Vtbl { unsafe extern "system" fn GetID, Impl: ISensor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -99,7 +99,7 @@ impl ISensor_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: ISensor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pproperty: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ISensor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&key)) { @@ -292,16 +292,16 @@ impl ISensorCollection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Devices_PortableDevices\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_Devices_PortableDevices\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait ISensorDataReport_Impl: Sized { fn GetTimestamp(&self) -> ::windows_core::Result; - fn GetSensorValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetSensorValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetSensorValues(&self, pkeys: ::core::option::Option<&super::PortableDevices::IPortableDeviceKeyCollection>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for ISensorDataReport {} -#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Devices_PortableDevices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ISensorDataReport_Vtbl { pub const fn new, Impl: ISensorDataReport_Impl, const OFFSET: isize>() -> ISensorDataReport_Vtbl { unsafe extern "system" fn GetTimestamp, Impl: ISensorDataReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptimestamp: *mut super::super::Foundation::SYSTEMTIME) -> ::windows_core::HRESULT { @@ -315,7 +315,7 @@ impl ISensorDataReport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetSensorValue, Impl: ISensorDataReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSensorValue, Impl: ISensorDataReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSensorValue(::core::mem::transmute_copy(&pkey)) { diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Sensors/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/Sensors/mod.rs index 684272143f..bac4a93072 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Sensors/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Sensors/mod.rs @@ -1,19 +1,19 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListAllocateBufferAndSerialize(sourcecollection: *const SENSOR_COLLECTION_LIST, ptargetbuffersizeinbytes: *mut u32, ptargetbuffer: *mut *mut u8) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListAllocateBufferAndSerialize(sourcecollection : *const SENSOR_COLLECTION_LIST, ptargetbuffersizeinbytes : *mut u32, ptargetbuffer : *mut *mut u8) -> super::super::Foundation:: NTSTATUS); CollectionsListAllocateBufferAndSerialize(sourcecollection, ptargetbuffersizeinbytes, ptargetbuffer) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListCopyAndMarshall(target: *mut SENSOR_COLLECTION_LIST, source: *const SENSOR_COLLECTION_LIST) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListCopyAndMarshall(target : *mut SENSOR_COLLECTION_LIST, source : *const SENSOR_COLLECTION_LIST) -> super::super::Foundation:: NTSTATUS); CollectionsListCopyAndMarshall(target, source) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListDeserializeFromBuffer(sourcebuffer: &[u8], targetcollection: *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListDeserializeFromBuffer(sourcebuffersizeinbytes : u32, sourcebuffer : *const u8, targetcollection : *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation:: NTSTATUS); @@ -24,57 +24,57 @@ pub unsafe fn CollectionsListGetFillableCount(buffersizebytes: u32) -> u32 { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListGetFillableCount(buffersizebytes : u32) -> u32); CollectionsListGetFillableCount(buffersizebytes) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListGetMarshalledSize(collection: *const SENSOR_COLLECTION_LIST) -> u32 { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListGetMarshalledSize(collection : *const SENSOR_COLLECTION_LIST) -> u32); CollectionsListGetMarshalledSize(collection) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListGetMarshalledSizeWithoutSerialization(collection: *const SENSOR_COLLECTION_LIST) -> u32 { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListGetMarshalledSizeWithoutSerialization(collection : *const SENSOR_COLLECTION_LIST) -> u32); CollectionsListGetMarshalledSizeWithoutSerialization(collection) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListGetSerializedSize(collection: *const SENSOR_COLLECTION_LIST) -> u32 { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListGetSerializedSize(collection : *const SENSOR_COLLECTION_LIST) -> u32); CollectionsListGetSerializedSize(collection) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListMarshall(target: *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListMarshall(target : *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation:: NTSTATUS); CollectionsListMarshall(target) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListSerializeToBuffer(sourcecollection: *const SENSOR_COLLECTION_LIST, targetbuffer: &mut [u8]) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListSerializeToBuffer(sourcecollection : *const SENSOR_COLLECTION_LIST, targetbuffersizeinbytes : u32, targetbuffer : *mut u8) -> super::super::Foundation:: NTSTATUS); CollectionsListSerializeToBuffer(sourcecollection, targetbuffer.len().try_into().unwrap(), ::core::mem::transmute(targetbuffer.as_ptr())) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListSortSubscribedActivitiesByConfidence(thresholds: *const SENSOR_COLLECTION_LIST, pcollection: *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListSortSubscribedActivitiesByConfidence(thresholds : *const SENSOR_COLLECTION_LIST, pcollection : *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation:: NTSTATUS); CollectionsListSortSubscribedActivitiesByConfidence(thresholds, pcollection) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn CollectionsListUpdateMarshalledPointer(collection: *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn CollectionsListUpdateMarshalledPointer(collection : *mut SENSOR_COLLECTION_LIST) -> super::super::Foundation:: NTSTATUS); CollectionsListUpdateMarshalledPointer(collection) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn EvaluateActivityThresholds(newsample: *const SENSOR_COLLECTION_LIST, oldsample: *const SENSOR_COLLECTION_LIST, thresholds: *const SENSOR_COLLECTION_LIST) -> super::super::Foundation::BOOLEAN { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn EvaluateActivityThresholds(newsample : *const SENSOR_COLLECTION_LIST, oldsample : *const SENSOR_COLLECTION_LIST, thresholds : *const SENSOR_COLLECTION_LIST) -> super::super::Foundation:: BOOLEAN); @@ -85,24 +85,20 @@ pub unsafe fn GetPerformanceTime(timems: *mut u32) -> super::super::Foundation:: ::windows_targets::link!("sensorsutilsv2.dll" "system" fn GetPerformanceTime(timems : *mut u32) -> super::super::Foundation:: NTSTATUS); GetPerformanceTime(timems) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn InitPropVariantFromCLSIDArray(members: &[::windows_core::GUID]) -> ::windows_core::Result { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn InitPropVariantFromCLSIDArray(members : *const ::windows_core::GUID, size : u32, ppropvar : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromCLSIDArray(members: &[::windows_core::GUID]) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn InitPropVariantFromCLSIDArray(members : *const ::windows_core::GUID, size : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromCLSIDArray(::core::mem::transmute(members.as_ptr()), members.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn InitPropVariantFromFloat(fltval: f32) -> ::windows_core::Result { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn InitPropVariantFromFloat(fltval : f32, ppropvar : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromFloat(fltval: f32) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn InitPropVariantFromFloat(fltval : f32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromFloat(fltval, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn IsCollectionListSame(lista: *const SENSOR_COLLECTION_LIST, listb: *const SENSOR_COLLECTION_LIST) -> super::super::Foundation::BOOLEAN { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn IsCollectionListSame(lista : *const SENSOR_COLLECTION_LIST, listb : *const SENSOR_COLLECTION_LIST) -> super::super::Foundation:: BOOLEAN); @@ -113,8 +109,8 @@ pub unsafe fn IsGUIDPresentInList(guidarray: &[::windows_core::GUID], guidelem: ::windows_targets::link!("sensorsutilsv2.dll" "system" fn IsGUIDPresentInList(guidarray : *const ::windows_core::GUID, arraylength : u32, guidelem : *const ::windows_core::GUID) -> super::super::Foundation:: BOOLEAN); IsGUIDPresentInList(::core::mem::transmute(guidarray.as_ptr()), guidarray.len().try_into().unwrap(), guidelem) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn IsKeyPresentInCollectionList(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> super::super::Foundation::BOOLEAN { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn IsKeyPresentInCollectionList(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY) -> super::super::Foundation:: BOOLEAN); @@ -127,123 +123,123 @@ pub unsafe fn IsKeyPresentInPropertyList(plist: *const SENSOR_PROPERTY_LIST, pke ::windows_targets::link!("sensorsutilsv2.dll" "system" fn IsKeyPresentInPropertyList(plist : *const SENSOR_PROPERTY_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY) -> super::super::Foundation:: BOOLEAN); IsKeyPresentInPropertyList(plist, pkey) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn IsSensorSubscribed(subscriptionlist: *const SENSOR_COLLECTION_LIST, currenttype: ::windows_core::GUID) -> super::super::Foundation::BOOLEAN { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn IsSensorSubscribed(subscriptionlist : *const SENSOR_COLLECTION_LIST, currenttype : ::windows_core::GUID) -> super::super::Foundation:: BOOLEAN); IsSensorSubscribed(subscriptionlist, ::core::mem::transmute(currenttype)) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetBool(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut super::super::Foundation::BOOL) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetBool(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut super::super::Foundation:: BOOL) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetBool(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetDouble(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut f64) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetDouble(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut f64) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetDouble(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetFileTime(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut super::super::Foundation::FILETIME) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetFileTime(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut super::super::Foundation:: FILETIME) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetFileTime(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetFloat(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut f32) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetFloat(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut f32) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetFloat(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetGuid(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut ::windows_core::GUID) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetGuid(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut ::windows_core::GUID) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetGuid(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetInt32(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut i32) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetInt32(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut i32) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetInt32(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetInt64(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut i64) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetInt64(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut i64) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetInt64(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetNthInt64(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, occurrence: u32, pretvalue: *mut i64) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetNthInt64(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, occurrence : u32, pretvalue : *mut i64) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetNthInt64(plist, pkey, occurrence, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetNthUlong(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, occurrence: u32, pretvalue: *mut u32) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetNthUlong(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, occurrence : u32, pretvalue : *mut u32) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetNthUlong(plist, pkey, occurrence, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetNthUshort(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, occurrence: u32, pretvalue: *mut u16) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetNthUshort(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, occurrence : u32, pretvalue : *mut u16) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetNthUshort(plist, pkey, occurrence, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] -pub unsafe fn PropKeyFindKeyGetPropVariant(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, typecheck: P0, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> super::super::Foundation::NTSTATUS +pub unsafe fn PropKeyFindKeyGetPropVariant(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, typecheck: P0, pvalue: *mut ::windows_core::PROPVARIANT) -> super::super::Foundation::NTSTATUS where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetPropVariant(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, typecheck : super::super::Foundation:: BOOLEAN, pvalue : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> super::super::Foundation:: NTSTATUS); - PropKeyFindKeyGetPropVariant(plist, pkey, typecheck.into_param().abi(), pvalue) + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetPropVariant(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, typecheck : super::super::Foundation:: BOOLEAN, pvalue : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> super::super::Foundation:: NTSTATUS); + PropKeyFindKeyGetPropVariant(plist, pkey, typecheck.into_param().abi(), ::core::mem::transmute(pvalue)) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetUlong(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut u32) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetUlong(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut u32) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetUlong(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] pub unsafe fn PropKeyFindKeyGetUshort(plist: *const SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pretvalue: *mut u16) -> super::super::Foundation::NTSTATUS { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeyGetUshort(plist : *const SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pretvalue : *mut u16) -> super::super::Foundation:: NTSTATUS); PropKeyFindKeyGetUshort(plist, pkey, pretvalue) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] -pub unsafe fn PropKeyFindKeySetPropVariant(plist: *mut SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, typecheck: P0, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> super::super::Foundation::NTSTATUS +pub unsafe fn PropKeyFindKeySetPropVariant(plist: *mut SENSOR_COLLECTION_LIST, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, typecheck: P0, pvalue: *const ::windows_core::PROPVARIANT) -> super::super::Foundation::NTSTATUS where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeySetPropVariant(plist : *mut SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, typecheck : super::super::Foundation:: BOOLEAN, pvalue : *const super::super::System::Com::StructuredStorage:: PROPVARIANT) -> super::super::Foundation:: NTSTATUS); - PropKeyFindKeySetPropVariant(plist, pkey, typecheck.into_param().abi(), pvalue) + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropKeyFindKeySetPropVariant(plist : *mut SENSOR_COLLECTION_LIST, pkey : *const super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, typecheck : super::super::Foundation:: BOOLEAN, pvalue : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> super::super::Foundation:: NTSTATUS); + PropKeyFindKeySetPropVariant(plist, pkey, typecheck.into_param().abi(), ::core::mem::transmute(pvalue)) } -#[doc = "Required features: `\"Win32_Devices_Properties\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Devices_Properties\"`"] +#[cfg(feature = "Win32_Devices_Properties")] #[inline] -pub unsafe fn PropVariantGetInformation(propvariantvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, propvariantoffset: ::core::option::Option<*mut u32>, propvariantsize: ::core::option::Option<*mut u32>, propvariantpointer: ::core::option::Option<*mut *mut ::core::ffi::c_void>, remappedtype: ::core::option::Option<*mut super::Properties::DEVPROPTYPE>) -> super::super::Foundation::NTSTATUS { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropVariantGetInformation(propvariantvalue : *const super::super::System::Com::StructuredStorage:: PROPVARIANT, propvariantoffset : *mut u32, propvariantsize : *mut u32, propvariantpointer : *mut *mut ::core::ffi::c_void, remappedtype : *mut super::Properties:: DEVPROPTYPE) -> super::super::Foundation:: NTSTATUS); - PropVariantGetInformation(propvariantvalue, ::core::mem::transmute(propvariantoffset.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(propvariantsize.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(propvariantpointer.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(remappedtype.unwrap_or(::std::ptr::null_mut()))) +pub unsafe fn PropVariantGetInformation(propvariantvalue: *const ::windows_core::PROPVARIANT, propvariantoffset: ::core::option::Option<*mut u32>, propvariantsize: ::core::option::Option<*mut u32>, propvariantpointer: ::core::option::Option<*mut *mut ::core::ffi::c_void>, remappedtype: ::core::option::Option<*mut super::Properties::DEVPROPTYPE>) -> super::super::Foundation::NTSTATUS { + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropVariantGetInformation(propvariantvalue : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, propvariantoffset : *mut u32, propvariantsize : *mut u32, propvariantpointer : *mut *mut ::core::ffi::c_void, remappedtype : *mut super::Properties:: DEVPROPTYPE) -> super::super::Foundation:: NTSTATUS); + PropVariantGetInformation(::core::mem::transmute(propvariantvalue), ::core::mem::transmute(propvariantoffset.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(propvariantsize.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(propvariantpointer.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(remappedtype.unwrap_or(::std::ptr::null_mut()))) } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -257,11 +253,11 @@ pub unsafe fn PropertiesListGetFillableCount(buffersizebytes: u32) -> u32 { ::windows_targets::link!("sensorsutilsv2.dll" "system" fn PropertiesListGetFillableCount(buffersizebytes : u32) -> u32); PropertiesListGetFillableCount(buffersizebytes) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] -pub unsafe fn SensorCollectionGetAt(index: u32, psensorslist: *const SENSOR_COLLECTION_LIST, pkey: ::core::option::Option<*mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> super::super::Foundation::NTSTATUS { - ::windows_targets::link!("sensorsutilsv2.dll" "system" fn SensorCollectionGetAt(index : u32, psensorslist : *const SENSOR_COLLECTION_LIST, pkey : *mut super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pvalue : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> super::super::Foundation:: NTSTATUS); +pub unsafe fn SensorCollectionGetAt(index: u32, psensorslist: *const SENSOR_COLLECTION_LIST, pkey: ::core::option::Option<*mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> super::super::Foundation::NTSTATUS { + ::windows_targets::link!("sensorsutilsv2.dll" "system" fn SensorCollectionGetAt(index : u32, psensorslist : *const SENSOR_COLLECTION_LIST, pkey : *mut super::super::UI::Shell::PropertiesSystem:: PROPERTYKEY, pvalue : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> super::super::Foundation:: NTSTATUS); SensorCollectionGetAt(index, psensorslist, ::core::mem::transmute(pkey.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))) } #[inline] @@ -311,9 +307,9 @@ impl ISensor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFriendlyName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } @@ -380,9 +376,9 @@ pub struct ISensor_Vtbl { pub GetCategory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psensorcategory: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psensortype: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetFriendlyName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfriendlyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pproperty: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetProperty: usize, #[cfg(feature = "Win32_Devices_PortableDevices")] pub GetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkeys: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -455,9 +451,9 @@ impl ISensorDataReport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetTimestamp)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetSensorValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetSensorValue(&self, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetSensorValue)(::windows_core::Interface::as_raw(self), pkey, &mut result__).from_abi(result__) } @@ -476,9 +472,9 @@ impl ISensorDataReport { pub struct ISensorDataReport_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetTimestamp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptimestamp: *mut super::super::Foundation::SYSTEMTIME) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetSensorValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetSensorValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetSensorValue: usize, #[cfg(feature = "Win32_Devices_PortableDevices")] pub GetSensorValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkeys: *mut ::core::ffi::c_void, ppvalues: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1620,24 +1616,38 @@ impl ::core::default::Default for QUATERNION { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub struct SENSOR_COLLECTION_LIST { pub AllocatedSizeInBytes: u32, pub Count: u32, pub List: [SENSOR_VALUE_PAIR; 1], } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::core::clone::Clone for SENSOR_COLLECTION_LIST { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::fmt::Debug for SENSOR_COLLECTION_LIST { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("SENSOR_COLLECTION_LIST").field("AllocatedSizeInBytes", &self.AllocatedSizeInBytes).field("Count", &self.Count).field("List", &self.List).finish() + } +} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::TypeKind for SENSOR_COLLECTION_LIST { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::cmp::PartialEq for SENSOR_COLLECTION_LIST { + fn eq(&self, other: &Self) -> bool { + self.AllocatedSizeInBytes == other.AllocatedSizeInBytes && self.Count == other.Count && self.List == other.List + } +} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::cmp::Eq for SENSOR_COLLECTION_LIST {} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::core::default::Default for SENSOR_COLLECTION_LIST { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -1684,23 +1694,37 @@ impl ::core::default::Default for SENSOR_PROPERTY_LIST { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub struct SENSOR_VALUE_PAIR { pub Key: super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, - pub Value: super::super::System::Com::StructuredStorage::PROPVARIANT, + pub Value: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::core::clone::Clone for SENSOR_VALUE_PAIR { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::fmt::Debug for SENSOR_VALUE_PAIR { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("SENSOR_VALUE_PAIR").field("Key", &self.Key).field("Value", &self.Value).finish() + } +} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::TypeKind for SENSOR_VALUE_PAIR { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::cmp::PartialEq for SENSOR_VALUE_PAIR { + fn eq(&self, other: &Self) -> bool { + self.Key == other.Key && self.Value == other.Value + } +} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] +impl ::core::cmp::Eq for SENSOR_VALUE_PAIR {} +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::core::default::Default for SENSOR_VALUE_PAIR { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Tapi/impl.rs b/crates/libs/windows/src/Windows/Win32/Devices/Tapi/impl.rs index c7f6ebc380..9084597107 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Tapi/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Tapi/impl.rs @@ -1108,23 +1108,23 @@ impl IEnumTerminalClass_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMcastAddressAllocation_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn Scopes(&self) -> ::windows_core::Result; + fn Scopes(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateScopes(&self) -> ::windows_core::Result; fn RequestAddress(&self, pscope: ::core::option::Option<&IMcastScope>, leasestarttime: f64, leasestoptime: f64, numaddresses: i32) -> ::windows_core::Result; fn RenewAddress(&self, lreserved: i32, prenewrequest: ::core::option::Option<&IMcastLeaseInfo>) -> ::windows_core::Result; fn ReleaseAddress(&self, preleaserequest: ::core::option::Option<&IMcastLeaseInfo>) -> ::windows_core::Result<()>; fn CreateLeaseInfo(&self, leasestarttime: f64, leasestoptime: f64, dwnumaddresses: u32, ppaddresses: *const ::windows_core::PCWSTR, prequestid: &::windows_core::PCWSTR, pserveraddress: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn CreateLeaseInfoFromVariant(&self, leasestarttime: f64, leasestoptime: f64, vaddresses: &super::super::System::Variant::VARIANT, prequestid: &::windows_core::BSTR, pserveraddress: &::windows_core::BSTR) -> ::windows_core::Result; + fn CreateLeaseInfoFromVariant(&self, leasestarttime: f64, leasestoptime: f64, vaddresses: &::windows_core::VARIANT, prequestid: &::windows_core::BSTR, pserveraddress: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMcastAddressAllocation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMcastAddressAllocation_Vtbl { pub const fn new, Impl: IMcastAddressAllocation_Impl, const OFFSET: isize>() -> IMcastAddressAllocation_Vtbl { - unsafe extern "system" fn Scopes, Impl: IMcastAddressAllocation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Scopes, Impl: IMcastAddressAllocation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Scopes() { @@ -1184,7 +1184,7 @@ impl IMcastAddressAllocation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateLeaseInfoFromVariant, Impl: IMcastAddressAllocation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, vaddresses: super::super::System::Variant::VARIANT, prequestid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pserveraddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppreleaserequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateLeaseInfoFromVariant, Impl: IMcastAddressAllocation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, vaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>, prequestid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pserveraddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppreleaserequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateLeaseInfoFromVariant(::core::mem::transmute_copy(&leasestarttime), ::core::mem::transmute_copy(&leasestoptime), ::core::mem::transmute(&vaddresses), ::core::mem::transmute(&prequestid), ::core::mem::transmute(&pserveraddress)) { @@ -1210,8 +1210,8 @@ impl IMcastAddressAllocation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMcastLeaseInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RequestID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LeaseStartTime(&self) -> ::windows_core::Result; @@ -1221,12 +1221,12 @@ pub trait IMcastLeaseInfo_Impl: Sized + super::super::System::Com::IDispatch_Imp fn AddressCount(&self) -> ::windows_core::Result; fn ServerAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TTL(&self) -> ::windows_core::Result; - fn Addresses(&self) -> ::windows_core::Result; + fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateAddresses(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMcastLeaseInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMcastLeaseInfo_Vtbl { pub const fn new, Impl: IMcastLeaseInfo_Impl, const OFFSET: isize>() -> IMcastLeaseInfo_Vtbl { unsafe extern "system" fn RequestID, Impl: IMcastLeaseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprequestid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1305,7 +1305,7 @@ impl IMcastLeaseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Addresses, Impl: IMcastLeaseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Addresses, Impl: IMcastLeaseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Addresses() { @@ -1345,8 +1345,8 @@ impl IMcastLeaseInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMcastScope_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ScopeID(&self) -> ::windows_core::Result; fn ServerID(&self) -> ::windows_core::Result; @@ -1354,9 +1354,9 @@ pub trait IMcastScope_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ScopeDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TTL(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMcastScope {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMcastScope_Vtbl { pub const fn new, Impl: IMcastScope_Impl, const OFFSET: isize>() -> IMcastScope_Vtbl { unsafe extern "system" fn ScopeID, Impl: IMcastScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut i32) -> ::windows_core::HRESULT { @@ -1427,16 +1427,16 @@ impl IMcastScope_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITACDGroup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EnumerateQueues(&self) -> ::windows_core::Result; - fn Queues(&self) -> ::windows_core::Result; + fn Queues(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITACDGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITACDGroup_Vtbl { pub const fn new, Impl: ITACDGroup_Impl, const OFFSET: isize>() -> ITACDGroup_Vtbl { unsafe extern "system" fn Name, Impl: ITACDGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1461,7 +1461,7 @@ impl ITACDGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Queues, Impl: ITACDGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Queues, Impl: ITACDGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Queues() { @@ -1483,15 +1483,15 @@ impl ITACDGroup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITACDGroupEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Group(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITACDGroupEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITACDGroupEvent_Vtbl { pub const fn new, Impl: ITACDGroupEvent_Impl, const OFFSET: isize>() -> ITACDGroupEvent_Vtbl { unsafe extern "system" fn Group, Impl: ITACDGroupEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1563,16 +1563,16 @@ impl ITAMMediaFormat_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITASRTerminalEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Terminal(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; fn Error(&self) -> ::windows_core::Result<::windows_core::HRESULT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITASRTerminalEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITASRTerminalEvent_Vtbl { pub const fn new, Impl: ITASRTerminalEvent_Impl, const OFFSET: isize>() -> ITASRTerminalEvent_Vtbl { unsafe extern "system" fn Terminal, Impl: ITASRTerminalEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1619,15 +1619,15 @@ impl ITASRTerminalEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddress_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn State(&self) -> ::windows_core::Result; fn AddressName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ServiceProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TAPIObject(&self) -> ::windows_core::Result; fn CreateCall(&self, pdestaddress: &::windows_core::BSTR, laddresstype: i32, lmediatypes: i32) -> ::windows_core::Result; - fn Calls(&self) -> ::windows_core::Result; + fn Calls(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateCalls(&self) -> ::windows_core::Result; fn DialableAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CreateForwardInfoObject(&self) -> ::windows_core::Result; @@ -1638,9 +1638,9 @@ pub trait ITAddress_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetDoNotDisturb(&self, fdonotdisturb: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn DoNotDisturb(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddress_Vtbl { pub const fn new, Impl: ITAddress_Impl, const OFFSET: isize>() -> ITAddress_Vtbl { unsafe extern "system" fn State, Impl: ITAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddressstate: *mut ADDRESS_STATE) -> ::windows_core::HRESULT { @@ -1698,7 +1698,7 @@ impl ITAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Calls, Impl: ITAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Calls, Impl: ITAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Calls() { @@ -1813,26 +1813,26 @@ impl ITAddress_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddress2_Impl: Sized + ITAddress_Impl { - fn Phones(&self) -> ::windows_core::Result; + fn Phones(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePhones(&self) -> ::windows_core::Result; fn GetPhoneFromTerminal(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result; - fn PreferredPhones(&self) -> ::windows_core::Result; + fn PreferredPhones(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePreferredPhones(&self) -> ::windows_core::Result; fn get_EventFilter(&self, tapievent: TAPI_EVENT, lsubevent: i32) -> ::windows_core::Result; fn put_EventFilter(&self, tapievent: TAPI_EVENT, lsubevent: i32, benable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn DeviceSpecific(&self, pcall: ::core::option::Option<&ITCallInfo>, pparams: *const u8, dwsize: u32) -> ::windows_core::Result<()>; - fn DeviceSpecificVariant(&self, pcall: ::core::option::Option<&ITCallInfo>, vardevspecificbytearray: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeviceSpecificVariant(&self, pcall: ::core::option::Option<&ITCallInfo>, vardevspecificbytearray: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn NegotiateExtVersion(&self, llowversion: i32, lhighversion: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddress2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddress2_Vtbl { pub const fn new, Impl: ITAddress2_Impl, const OFFSET: isize>() -> ITAddress2_Vtbl { - unsafe extern "system" fn Phones, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Phones, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Phones() { @@ -1865,7 +1865,7 @@ impl ITAddress2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PreferredPhones, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PreferredPhones, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PreferredPhones() { @@ -1908,7 +1908,7 @@ impl ITAddress2_Vtbl { let this = (*this).get_impl(); this.DeviceSpecific(::windows_core::from_raw_borrowed(&pcall), ::core::mem::transmute_copy(&pparams), ::core::mem::transmute_copy(&dwsize)).into() } - unsafe extern "system" fn DeviceSpecificVariant, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcall: *mut ::core::ffi::c_void, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeviceSpecificVariant, Impl: ITAddress2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcall: *mut ::core::ffi::c_void, vardevspecificbytearray: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeviceSpecificVariant(::windows_core::from_raw_borrowed(&pcall), ::core::mem::transmute(&vardevspecificbytearray)).into() @@ -1942,21 +1942,21 @@ impl ITAddress2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddressCapabilities_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_AddressCapability(&self, addresscap: ADDRESS_CAPABILITY) -> ::windows_core::Result; fn get_AddressCapabilityString(&self, addresscapstring: ADDRESS_CAPABILITY_STRING) -> ::windows_core::Result<::windows_core::BSTR>; - fn CallTreatments(&self) -> ::windows_core::Result; + fn CallTreatments(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateCallTreatments(&self) -> ::windows_core::Result; - fn CompletionMessages(&self) -> ::windows_core::Result; + fn CompletionMessages(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateCompletionMessages(&self) -> ::windows_core::Result; - fn DeviceClasses(&self) -> ::windows_core::Result; + fn DeviceClasses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateDeviceClasses(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddressCapabilities {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddressCapabilities_Vtbl { pub const fn new, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>() -> ITAddressCapabilities_Vtbl { unsafe extern "system" fn get_AddressCapability, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, addresscap: ADDRESS_CAPABILITY, plcapability: *mut i32) -> ::windows_core::HRESULT { @@ -1981,7 +1981,7 @@ impl ITAddressCapabilities_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CallTreatments, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CallTreatments, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CallTreatments() { @@ -2003,7 +2003,7 @@ impl ITAddressCapabilities_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CompletionMessages, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CompletionMessages, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CompletionMessages() { @@ -2025,7 +2025,7 @@ impl ITAddressCapabilities_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeviceClasses, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeviceClasses, Impl: ITAddressCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DeviceClasses() { @@ -2063,8 +2063,8 @@ impl ITAddressCapabilities_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddressDeviceSpecificEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Address(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; @@ -2072,9 +2072,9 @@ pub trait ITAddressDeviceSpecificEvent_Impl: Sized + super::super::System::Com:: fn lParam2(&self) -> ::windows_core::Result; fn lParam3(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddressDeviceSpecificEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddressDeviceSpecificEvent_Vtbl { pub const fn new, Impl: ITAddressDeviceSpecificEvent_Impl, const OFFSET: isize>() -> ITAddressDeviceSpecificEvent_Vtbl { unsafe extern "system" fn Address, Impl: ITAddressDeviceSpecificEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2145,16 +2145,16 @@ impl ITAddressDeviceSpecificEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddressEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Address(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; fn Terminal(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddressEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddressEvent_Vtbl { pub const fn new, Impl: ITAddressEvent_Impl, const OFFSET: isize>() -> ITAddressEvent_Vtbl { unsafe extern "system" fn Address, Impl: ITAddressEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2201,19 +2201,19 @@ impl ITAddressEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddressTranslation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TranslateAddress(&self, paddresstotranslate: &::windows_core::BSTR, lcard: i32, ltranslateoptions: i32) -> ::windows_core::Result; fn TranslateDialog(&self, hwndowner: isize, paddressin: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn EnumerateLocations(&self) -> ::windows_core::Result; - fn Locations(&self) -> ::windows_core::Result; + fn Locations(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateCallingCards(&self) -> ::windows_core::Result; - fn CallingCards(&self) -> ::windows_core::Result; + fn CallingCards(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddressTranslation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddressTranslation_Vtbl { pub const fn new, Impl: ITAddressTranslation_Impl, const OFFSET: isize>() -> ITAddressTranslation_Vtbl { unsafe extern "system" fn TranslateAddress, Impl: ITAddressTranslation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresstotranslate: ::std::mem::MaybeUninit<::windows_core::BSTR>, lcard: i32, ltranslateoptions: i32, pptranslated: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2243,7 +2243,7 @@ impl ITAddressTranslation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Locations, Impl: ITAddressTranslation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Locations, Impl: ITAddressTranslation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Locations() { @@ -2265,7 +2265,7 @@ impl ITAddressTranslation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CallingCards, Impl: ITAddressTranslation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CallingCards, Impl: ITAddressTranslation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CallingCards() { @@ -2290,8 +2290,8 @@ impl ITAddressTranslation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAddressTranslationInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DialableString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DisplayableString(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2299,9 +2299,9 @@ pub trait ITAddressTranslationInfo_Impl: Sized + super::super::System::Com::IDis fn DestinationCountryCode(&self) -> ::windows_core::Result; fn TranslationResults(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAddressTranslationInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAddressTranslationInfo_Vtbl { pub const fn new, Impl: ITAddressTranslationInfo_Impl, const OFFSET: isize>() -> ITAddressTranslationInfo_Vtbl { unsafe extern "system" fn DialableString, Impl: ITAddressTranslationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdialablestring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2372,8 +2372,8 @@ impl ITAddressTranslationInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EnumerateAgentSessions(&self) -> ::windows_core::Result; fn CreateSession(&self, pacdgroup: ::core::option::Option<&ITACDGroup>, paddress: ::core::option::Option<&ITAddress>) -> ::windows_core::Result; @@ -2391,11 +2391,11 @@ pub trait ITAgent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TotalACDTalkTime(&self) -> ::windows_core::Result; fn TotalACDCallTime(&self) -> ::windows_core::Result; fn TotalWrapUpTime(&self) -> ::windows_core::Result; - fn AgentSessions(&self) -> ::windows_core::Result; + fn AgentSessions(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgent_Vtbl { pub const fn new, Impl: ITAgent_Impl, const OFFSET: isize>() -> ITAgent_Vtbl { unsafe extern "system" fn EnumerateAgentSessions, Impl: ITAgent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumagentsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2562,7 +2562,7 @@ impl ITAgent_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AgentSessions, Impl: ITAgent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AgentSessions, Impl: ITAgent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AgentSessions() { @@ -2598,15 +2598,15 @@ impl ITAgent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgentEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Agent(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgentEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgentEvent_Vtbl { pub const fn new, Impl: ITAgentEvent_Impl, const OFFSET: isize>() -> ITAgentEvent_Vtbl { unsafe extern "system" fn Agent, Impl: ITAgentEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppagent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2641,20 +2641,20 @@ impl ITAgentEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgentHandler_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CreateAgent(&self) -> ::windows_core::Result; fn CreateAgentWithID(&self, pid: &::windows_core::BSTR, ppin: &::windows_core::BSTR) -> ::windows_core::Result; fn EnumerateACDGroups(&self) -> ::windows_core::Result; fn EnumerateUsableAddresses(&self) -> ::windows_core::Result; - fn ACDGroups(&self) -> ::windows_core::Result; - fn UsableAddresses(&self) -> ::windows_core::Result; + fn ACDGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn UsableAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgentHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgentHandler_Vtbl { pub const fn new, Impl: ITAgentHandler_Impl, const OFFSET: isize>() -> ITAgentHandler_Vtbl { unsafe extern "system" fn Name, Impl: ITAgentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2712,7 +2712,7 @@ impl ITAgentHandler_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ACDGroups, Impl: ITAgentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ACDGroups, Impl: ITAgentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ACDGroups() { @@ -2723,7 +2723,7 @@ impl ITAgentHandler_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn UsableAddresses, Impl: ITAgentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UsableAddresses, Impl: ITAgentHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.UsableAddresses() { @@ -2749,15 +2749,15 @@ impl ITAgentHandler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgentHandlerEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AgentHandler(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgentHandlerEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgentHandlerEvent_Vtbl { pub const fn new, Impl: ITAgentHandlerEvent_Impl, const OFFSET: isize>() -> ITAgentHandlerEvent_Vtbl { unsafe extern "system" fn AgentHandler, Impl: ITAgentHandlerEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppagenthandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2792,8 +2792,8 @@ impl ITAgentHandlerEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgentSession_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Agent(&self) -> ::windows_core::Result; fn Address(&self) -> ::windows_core::Result; @@ -2813,9 +2813,9 @@ pub trait ITAgentSession_Impl: Sized + super::super::System::Com::IDispatch_Impl fn LongestTimeToAnswer(&self) -> ::windows_core::Result; fn AverageTimeToAnswer(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgentSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgentSession_Vtbl { pub const fn new, Impl: ITAgentSession_Impl, const OFFSET: isize>() -> ITAgentSession_Vtbl { unsafe extern "system" fn Agent, Impl: ITAgentSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppagent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3024,15 +3024,15 @@ impl ITAgentSession_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAgentSessionEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAgentSessionEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAgentSessionEvent_Vtbl { pub const fn new, Impl: ITAgentSessionEvent_Impl, const OFFSET: isize>() -> ITAgentSessionEvent_Vtbl { unsafe extern "system" fn Session, Impl: ITAgentSessionEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3144,8 +3144,8 @@ impl ITAllocatorProperties_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITAutomatedPhoneControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartTone(&self, tone: PHONE_TONE, lduration: i32) -> ::windows_core::Result<()>; fn StopTone(&self) -> ::windows_core::Result<()>; @@ -3178,11 +3178,11 @@ pub trait ITAutomatedPhoneControl_Impl: Sized + super::super::System::Com::IDisp fn SelectCall(&self, pcall: ::core::option::Option<&ITCallInfo>, fselectdefaultterminals: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn UnselectCall(&self, pcall: ::core::option::Option<&ITCallInfo>) -> ::windows_core::Result<()>; fn EnumerateSelectedCalls(&self) -> ::windows_core::Result; - fn SelectedCalls(&self) -> ::windows_core::Result; + fn SelectedCalls(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITAutomatedPhoneControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITAutomatedPhoneControl_Vtbl { pub const fn new, Impl: ITAutomatedPhoneControl_Impl, const OFFSET: isize>() -> ITAutomatedPhoneControl_Vtbl { unsafe extern "system" fn StartTone, Impl: ITAutomatedPhoneControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tone: PHONE_TONE, lduration: i32) -> ::windows_core::HRESULT { @@ -3424,7 +3424,7 @@ impl ITAutomatedPhoneControl_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SelectedCalls, Impl: ITAutomatedPhoneControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelectedCalls, Impl: ITAutomatedPhoneControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelectedCalls() { @@ -3475,17 +3475,17 @@ impl ITAutomatedPhoneControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITBasicAudioTerminal_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetVolume(&self, lvolume: i32) -> ::windows_core::Result<()>; fn Volume(&self) -> ::windows_core::Result; fn SetBalance(&self, lbalance: i32) -> ::windows_core::Result<()>; fn Balance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITBasicAudioTerminal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITBasicAudioTerminal_Vtbl { pub const fn new, Impl: ITBasicAudioTerminal_Impl, const OFFSET: isize>() -> ITBasicAudioTerminal_Vtbl { unsafe extern "system" fn SetVolume, Impl: ITBasicAudioTerminal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lvolume: i32) -> ::windows_core::HRESULT { @@ -3532,8 +3532,8 @@ impl ITBasicAudioTerminal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITBasicCallControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Connect(&self, fsync: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Answer(&self) -> ::windows_core::Result<()>; @@ -3554,9 +3554,9 @@ pub trait ITBasicCallControl_Impl: Sized + super::super::System::Com::IDispatch_ fn Finish(&self, finishmode: FINISH_MODE) -> ::windows_core::Result<()>; fn RemoveFromConference(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITBasicCallControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITBasicCallControl_Vtbl { pub const fn new, Impl: ITBasicCallControl_Impl, const OFFSET: isize>() -> ITBasicCallControl_Vtbl { unsafe extern "system" fn Connect, Impl: ITBasicCallControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fsync: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3681,16 +3681,16 @@ impl ITBasicCallControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITBasicCallControl2_Impl: Sized + ITBasicCallControl_Impl { fn RequestTerminal(&self, bstrterminalclassguid: &::windows_core::BSTR, lmediatype: i32, direction: TERMINAL_DIRECTION) -> ::windows_core::Result; fn SelectTerminalOnCall(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; fn UnselectTerminalOnCall(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITBasicCallControl2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITBasicCallControl2_Vtbl { pub const fn new, Impl: ITBasicCallControl2_Impl, const OFFSET: isize>() -> ITBasicCallControl2_Vtbl { unsafe extern "system" fn RequestTerminal, Impl: ITBasicCallControl2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrterminalclassguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, direction: TERMINAL_DIRECTION, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3725,18 +3725,18 @@ impl ITBasicCallControl2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallHub_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Clear(&self) -> ::windows_core::Result<()>; fn EnumerateCalls(&self) -> ::windows_core::Result; - fn Calls(&self) -> ::windows_core::Result; + fn Calls(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn NumCalls(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallHub {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallHub_Vtbl { pub const fn new, Impl: ITCallHub_Impl, const OFFSET: isize>() -> ITCallHub_Vtbl { unsafe extern "system" fn Clear, Impl: ITCallHub_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3755,7 +3755,7 @@ impl ITCallHub_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Calls, Impl: ITCallHub_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcalls: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Calls, Impl: ITCallHub_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcalls: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Calls() { @@ -3801,16 +3801,16 @@ impl ITCallHub_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallHubEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Event(&self) -> ::windows_core::Result; fn CallHub(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallHubEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallHubEvent_Vtbl { pub const fn new, Impl: ITCallHubEvent_Impl, const OFFSET: isize>() -> ITCallHubEvent_Vtbl { unsafe extern "system" fn Event, Impl: ITCallHubEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pevent: *mut CALLHUB_EVENT) -> ::windows_core::HRESULT { @@ -3857,8 +3857,8 @@ impl ITCallHubEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Address(&self) -> ::windows_core::Result; fn CallState(&self) -> ::windows_core::Result; @@ -3868,15 +3868,15 @@ pub trait ITCallInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn put_CallInfoLong(&self, callinfolong: CALLINFO_LONG, lcallinfolongval: i32) -> ::windows_core::Result<()>; fn get_CallInfoString(&self, callinfostring: CALLINFO_STRING) -> ::windows_core::Result<::windows_core::BSTR>; fn put_CallInfoString(&self, callinfostring: CALLINFO_STRING, pcallinfostring: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result; - fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetCallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pdwsize: *mut u32, ppcallinfobuffer: *mut *mut u8) -> ::windows_core::Result<()>; fn SetCallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, dwsize: u32, pcallinfobuffer: *const u8) -> ::windows_core::Result<()>; fn ReleaseUserUserInfo(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallInfo_Vtbl { pub const fn new, Impl: ITCallInfo_Impl, const OFFSET: isize>() -> ITCallInfo_Vtbl { unsafe extern "system" fn Address, Impl: ITCallInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3955,7 +3955,7 @@ impl ITCallInfo_Vtbl { let this = (*this).get_impl(); this.put_CallInfoString(::core::mem::transmute_copy(&callinfostring), ::core::mem::transmute(&pcallinfostring)).into() } - unsafe extern "system" fn get_CallInfoBuffer, Impl: ITCallInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, ppcallinfobuffer: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_CallInfoBuffer, Impl: ITCallInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, ppcallinfobuffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_CallInfoBuffer(::core::mem::transmute_copy(&callinfobuffer)) { @@ -3966,7 +3966,7 @@ impl ITCallInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_CallInfoBuffer, Impl: ITCallInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_CallInfoBuffer, Impl: ITCallInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_CallInfoBuffer(::core::mem::transmute_copy(&callinfobuffer), ::core::mem::transmute(&pcallinfobuffer)).into() @@ -4007,15 +4007,15 @@ impl ITCallInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallInfo2_Impl: Sized + ITCallInfo_Impl { fn get_EventFilter(&self, tapievent: TAPI_EVENT, lsubevent: i32) -> ::windows_core::Result; fn put_EventFilter(&self, tapievent: TAPI_EVENT, lsubevent: i32, benable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallInfo2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallInfo2_Vtbl { pub const fn new, Impl: ITCallInfo2_Impl, const OFFSET: isize>() -> ITCallInfo2_Vtbl { unsafe extern "system" fn get_EventFilter, Impl: ITCallInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tapievent: TAPI_EVENT, lsubevent: i32, penable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4044,16 +4044,16 @@ impl ITCallInfo2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallInfoChangeEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Cause(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallInfoChangeEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallInfoChangeEvent_Vtbl { pub const fn new, Impl: ITCallInfoChangeEvent_Impl, const OFFSET: isize>() -> ITCallInfoChangeEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITCallInfoChangeEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcall: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4100,8 +4100,8 @@ impl ITCallInfoChangeEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallMediaEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; @@ -4110,9 +4110,9 @@ pub trait ITCallMediaEvent_Impl: Sized + super::super::System::Com::IDispatch_Im fn Stream(&self) -> ::windows_core::Result; fn Cause(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallMediaEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallMediaEvent_Vtbl { pub const fn new, Impl: ITCallMediaEvent_Impl, const OFFSET: isize>() -> ITCallMediaEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITCallMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4195,16 +4195,16 @@ impl ITCallMediaEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallNotificationEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallNotificationEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallNotificationEvent_Vtbl { pub const fn new, Impl: ITCallNotificationEvent_Impl, const OFFSET: isize>() -> ITCallNotificationEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITCallNotificationEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcall: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4251,17 +4251,17 @@ impl ITCallNotificationEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallStateEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; fn Cause(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallStateEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallStateEvent_Vtbl { pub const fn new, Impl: ITCallStateEvent_Impl, const OFFSET: isize>() -> ITCallStateEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITCallStateEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4320,8 +4320,8 @@ impl ITCallStateEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCallingCard_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn PermanentCardID(&self) -> ::windows_core::Result; fn NumberOfDigits(&self) -> ::windows_core::Result; @@ -4331,9 +4331,9 @@ pub trait ITCallingCard_Impl: Sized + super::super::System::Com::IDispatch_Impl fn LongDistanceDialingRule(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InternationalDialingRule(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCallingCard {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCallingCard_Vtbl { pub const fn new, Impl: ITCallingCard_Impl, const OFFSET: isize>() -> ITCallingCard_Vtbl { unsafe extern "system" fn PermanentCardID, Impl: ITCallingCard_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcardid: *mut i32) -> ::windows_core::HRESULT { @@ -4428,16 +4428,16 @@ impl ITCallingCard_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCollection_Vtbl { pub const fn new, Impl: ITCollection_Impl, const OFFSET: isize>() -> ITCollection_Vtbl { unsafe extern "system" fn Count, Impl: ITCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -4451,7 +4451,7 @@ impl ITCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ITCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ITCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -4484,18 +4484,18 @@ impl ITCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCollection2_Impl: Sized + ITCollection_Impl { - fn Add(&self, index: i32, pvariant: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Add(&self, index: i32, pvariant: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Remove(&self, index: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCollection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCollection2_Vtbl { pub const fn new, Impl: ITCollection2_Impl, const OFFSET: isize>() -> ITCollection2_Vtbl { - unsafe extern "system" fn Add, Impl: ITCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: ITCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&pvariant)).into() @@ -4511,8 +4511,8 @@ impl ITCollection2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITCustomTone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Frequency(&self) -> ::windows_core::Result; fn SetFrequency(&self, lfrequency: i32) -> ::windows_core::Result<()>; @@ -4523,9 +4523,9 @@ pub trait ITCustomTone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Volume(&self) -> ::windows_core::Result; fn SetVolume(&self, lvolume: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITCustomTone {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITCustomTone_Vtbl { pub const fn new, Impl: ITCustomTone_Impl, const OFFSET: isize>() -> ITCustomTone_Vtbl { unsafe extern "system" fn Frequency, Impl: ITCustomTone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plfrequency: *mut i32) -> ::windows_core::HRESULT { @@ -4608,8 +4608,8 @@ impl ITCustomTone_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDetectTone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AppSpecific(&self) -> ::windows_core::Result; fn SetAppSpecific(&self, lappspecific: i32) -> ::windows_core::Result<()>; @@ -4618,9 +4618,9 @@ pub trait ITDetectTone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_Frequency(&self, index: i32) -> ::windows_core::Result; fn put_Frequency(&self, index: i32, lfrequency: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDetectTone {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDetectTone_Vtbl { pub const fn new, Impl: ITDetectTone_Impl, const OFFSET: isize>() -> ITDetectTone_Vtbl { unsafe extern "system" fn AppSpecific, Impl: ITDetectTone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plappspecific: *mut i32) -> ::windows_core::HRESULT { @@ -4685,8 +4685,8 @@ impl ITDetectTone_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDigitDetectionEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Digit(&self) -> ::windows_core::Result; @@ -4694,9 +4694,9 @@ pub trait ITDigitDetectionEvent_Impl: Sized + super::super::System::Com::IDispat fn TickCount(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDigitDetectionEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDigitDetectionEvent_Vtbl { pub const fn new, Impl: ITDigitDetectionEvent_Impl, const OFFSET: isize>() -> ITDigitDetectionEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITDigitDetectionEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4767,17 +4767,17 @@ impl ITDigitDetectionEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDigitGenerationEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn GenerationTermination(&self) -> ::windows_core::Result; fn TickCount(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDigitGenerationEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDigitGenerationEvent_Vtbl { pub const fn new, Impl: ITDigitGenerationEvent_Impl, const OFFSET: isize>() -> ITDigitGenerationEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITDigitGenerationEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4836,8 +4836,8 @@ impl ITDigitGenerationEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDigitsGatheredEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Digits(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4845,9 +4845,9 @@ pub trait ITDigitsGatheredEvent_Impl: Sized + super::super::System::Com::IDispat fn TickCount(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDigitsGatheredEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDigitsGatheredEvent_Vtbl { pub const fn new, Impl: ITDigitsGatheredEvent_Impl, const OFFSET: isize>() -> ITDigitsGatheredEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITDigitsGatheredEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4918,8 +4918,8 @@ impl ITDigitsGatheredEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDirectory_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DirectoryType(&self) -> ::windows_core::Result; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4933,12 +4933,12 @@ pub trait ITDirectory_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ModifyDirectoryObject(&self, pdirectoryobject: ::core::option::Option<&ITDirectoryObject>) -> ::windows_core::Result<()>; fn RefreshDirectoryObject(&self, pdirectoryobject: ::core::option::Option<&ITDirectoryObject>) -> ::windows_core::Result<()>; fn DeleteDirectoryObject(&self, pdirectoryobject: ::core::option::Option<&ITDirectoryObject>) -> ::windows_core::Result<()>; - fn get_DirectoryObjects(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_DirectoryObjects(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateDirectoryObjects(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDirectory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDirectory_Vtbl { pub const fn new, Impl: ITDirectory_Impl, const OFFSET: isize>() -> ITDirectory_Vtbl { unsafe extern "system" fn DirectoryType, Impl: ITDirectory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdirectorytype: *mut DIRECTORY_TYPE) -> ::windows_core::HRESULT { @@ -5025,7 +5025,7 @@ impl ITDirectory_Vtbl { let this = (*this).get_impl(); this.DeleteDirectoryObject(::windows_core::from_raw_borrowed(&pdirectoryobject)).into() } - unsafe extern "system" fn get_DirectoryObjects, Impl: ITDirectory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_DirectoryObjects, Impl: ITDirectory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_DirectoryObjects(::core::mem::transmute_copy(&directoryobjecttype), ::core::mem::transmute(&pname)) { @@ -5069,20 +5069,20 @@ impl ITDirectory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDirectoryObject_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ObjectType(&self) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, pname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn get_DialableAddrs(&self, dwaddresstype: i32) -> ::windows_core::Result; + fn get_DialableAddrs(&self, dwaddresstype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateDialableAddrs(&self, dwaddresstype: u32) -> ::windows_core::Result; fn SecurityDescriptor(&self) -> ::windows_core::Result; fn SetSecurityDescriptor(&self, psecdes: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDirectoryObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDirectoryObject_Vtbl { pub const fn new, Impl: ITDirectoryObject_Impl, const OFFSET: isize>() -> ITDirectoryObject_Vtbl { unsafe extern "system" fn ObjectType, Impl: ITDirectoryObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjecttype: *mut DIRECTORY_OBJECT_TYPE) -> ::windows_core::HRESULT { @@ -5112,7 +5112,7 @@ impl ITDirectoryObject_Vtbl { let this = (*this).get_impl(); this.SetName(::core::mem::transmute(&pname)).into() } - unsafe extern "system" fn get_DialableAddrs, Impl: ITDirectoryObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwaddresstype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_DialableAddrs, Impl: ITDirectoryObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwaddresstype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_DialableAddrs(::core::mem::transmute_copy(&dwaddresstype)) { @@ -5165,8 +5165,8 @@ impl ITDirectoryObject_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDirectoryObjectConference_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Protocol(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Originator(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5184,9 +5184,9 @@ pub trait ITDirectoryObjectConference_Impl: Sized + super::super::System::Com::I fn StopTime(&self) -> ::windows_core::Result; fn SetStopTime(&self, date: f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDirectoryObjectConference {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDirectoryObjectConference_Vtbl { pub const fn new, Impl: ITDirectoryObjectConference_Impl, const OFFSET: isize>() -> ITDirectoryObjectConference_Vtbl { unsafe extern "system" fn Protocol, Impl: ITDirectoryObjectConference_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppprotocol: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5335,15 +5335,15 @@ impl ITDirectoryObjectConference_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDirectoryObjectUser_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IPPhonePrimary(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetIPPhonePrimary(&self, pname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDirectoryObjectUser {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDirectoryObjectUser_Vtbl { pub const fn new, Impl: ITDirectoryObjectUser_Impl, const OFFSET: isize>() -> ITDirectoryObjectUser_Vtbl { unsafe extern "system" fn IPPhonePrimary, Impl: ITDirectoryObjectUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5372,14 +5372,14 @@ impl ITDirectoryObjectUser_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITDispatchMapper_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn QueryDispatchInterface(&self, piid: &::windows_core::BSTR, pinterfacetomap: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITDispatchMapper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITDispatchMapper_Vtbl { pub const fn new, Impl: ITDispatchMapper_Impl, const OFFSET: isize>() -> ITDispatchMapper_Vtbl { unsafe extern "system" fn QueryDispatchInterface, Impl: ITDispatchMapper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, piid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pinterfacetomap: *mut ::core::ffi::c_void, ppreturnedinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5402,8 +5402,8 @@ impl ITDispatchMapper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITFileTerminalEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Terminal(&self) -> ::windows_core::Result; fn Track(&self) -> ::windows_core::Result; @@ -5412,9 +5412,9 @@ pub trait ITFileTerminalEvent_Impl: Sized + super::super::System::Com::IDispatch fn Cause(&self) -> ::windows_core::Result; fn Error(&self) -> ::windows_core::Result<::windows_core::HRESULT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITFileTerminalEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITFileTerminalEvent_Vtbl { pub const fn new, Impl: ITFileTerminalEvent_Impl, const OFFSET: isize>() -> ITFileTerminalEvent_Vtbl { unsafe extern "system" fn Terminal, Impl: ITFileTerminalEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5497,8 +5497,8 @@ impl ITFileTerminalEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait ITFileTrack_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Format(&self) -> ::windows_core::Result<*mut super::super::Media::MediaFoundation::AM_MEDIA_TYPE>; fn SetFormat(&self, pmt: *const super::super::Media::MediaFoundation::AM_MEDIA_TYPE) -> ::windows_core::Result<()>; @@ -5507,9 +5507,9 @@ pub trait ITFileTrack_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetAudioFormatForScripting(&self, paudioformat: ::core::option::Option<&ITScriptableAudioFormat>) -> ::windows_core::Result<()>; fn EmptyAudioFormatForScripting(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ITFileTrack {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ITFileTrack_Vtbl { pub const fn new, Impl: ITFileTrack_Impl, const OFFSET: isize>() -> ITFileTrack_Vtbl { unsafe extern "system" fn Format, Impl: ITFileTrack_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmt: *mut *mut super::super::Media::MediaFoundation::AM_MEDIA_TYPE) -> ::windows_core::HRESULT { @@ -5580,8 +5580,8 @@ impl ITFileTrack_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITForwardInformation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetNumRingsNoAnswer(&self, lnumrings: i32) -> ::windows_core::Result<()>; fn NumRingsNoAnswer(&self) -> ::windows_core::Result; @@ -5591,9 +5591,9 @@ pub trait ITForwardInformation_Impl: Sized + super::super::System::Com::IDispatc fn GetForwardType(&self, forwardtype: i32, ppdestinationaddress: *mut ::windows_core::BSTR, ppcalleraddress: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITForwardInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITForwardInformation_Vtbl { pub const fn new, Impl: ITForwardInformation_Impl, const OFFSET: isize>() -> ITForwardInformation_Vtbl { unsafe extern "system" fn SetNumRingsNoAnswer, Impl: ITForwardInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnumrings: i32) -> ::windows_core::HRESULT { @@ -5664,17 +5664,17 @@ impl ITForwardInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITForwardInformation2_Impl: Sized + ITForwardInformation_Impl { fn SetForwardType2(&self, forwardtype: i32, pdestaddress: &::windows_core::BSTR, destaddresstype: i32, pcalleraddress: &::windows_core::BSTR, calleraddresstype: i32) -> ::windows_core::Result<()>; fn GetForwardType2(&self, forwardtype: i32, ppdestinationaddress: *mut ::windows_core::BSTR, pdestaddresstype: *mut i32, ppcalleraddress: *mut ::windows_core::BSTR, pcalleraddresstype: *mut i32) -> ::windows_core::Result<()>; fn get_ForwardTypeDestinationAddressType(&self, forwardtype: i32) -> ::windows_core::Result; fn get_ForwardTypeCallerAddressType(&self, forwardtype: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITForwardInformation2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITForwardInformation2_Vtbl { pub const fn new, Impl: ITForwardInformation2_Impl, const OFFSET: isize>() -> ITForwardInformation2_Vtbl { unsafe extern "system" fn SetForwardType2, Impl: ITForwardInformation2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, forwardtype: i32, pdestaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, destaddresstype: i32, pcalleraddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, calleraddresstype: i32) -> ::windows_core::HRESULT { @@ -5721,15 +5721,15 @@ impl ITForwardInformation2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITILSConfig_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Port(&self) -> ::windows_core::Result; fn SetPort(&self, port: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITILSConfig {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITILSConfig_Vtbl { pub const fn new, Impl: ITILSConfig_Impl, const OFFSET: isize>() -> ITILSConfig_Vtbl { unsafe extern "system" fn Port, Impl: ITILSConfig_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pport: *mut i32) -> ::windows_core::HRESULT { @@ -5819,8 +5819,8 @@ impl ITLegacyAddressMediaControl2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITLegacyCallMediaControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DetectDigits(&self, digitmode: i32) -> ::windows_core::Result<()>; fn GenerateDigits(&self, pdigits: &::windows_core::BSTR, digitmode: i32) -> ::windows_core::Result<()>; @@ -5828,9 +5828,9 @@ pub trait ITLegacyCallMediaControl_Impl: Sized + super::super::System::Com::IDis fn SetMediaType(&self, lmediatype: i32) -> ::windows_core::Result<()>; fn MonitorMedia(&self, lmediatype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITLegacyCallMediaControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITLegacyCallMediaControl_Vtbl { pub const fn new, Impl: ITLegacyCallMediaControl_Impl, const OFFSET: isize>() -> ITLegacyCallMediaControl_Vtbl { unsafe extern "system" fn DetectDigits, Impl: ITLegacyCallMediaControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, digitmode: i32) -> ::windows_core::HRESULT { @@ -5871,8 +5871,8 @@ impl ITLegacyCallMediaControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITLegacyCallMediaControl2_Impl: Sized + ITLegacyCallMediaControl_Impl { fn GenerateDigits2(&self, pdigits: &::windows_core::BSTR, digitmode: i32, lduration: i32) -> ::windows_core::Result<()>; fn GatherDigits(&self, digitmode: i32, lnumdigits: i32, pterminationdigits: &::windows_core::BSTR, lfirstdigittimeout: i32, linterdigittimeout: i32) -> ::windows_core::Result<()>; @@ -5883,11 +5883,11 @@ pub trait ITLegacyCallMediaControl2_Impl: Sized + ITLegacyCallMediaControl_Impl fn GenerateCustomTonesByCollection(&self, pcustomtonecollection: ::core::option::Option<&ITCollection2>, lduration: i32) -> ::windows_core::Result<()>; fn CreateDetectToneObject(&self) -> ::windows_core::Result; fn CreateCustomToneObject(&self) -> ::windows_core::Result; - fn GetIDAsVariant(&self, bstrdeviceclass: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetIDAsVariant(&self, bstrdeviceclass: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITLegacyCallMediaControl2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITLegacyCallMediaControl2_Vtbl { pub const fn new, Impl: ITLegacyCallMediaControl2_Impl, const OFFSET: isize>() -> ITLegacyCallMediaControl2_Vtbl { unsafe extern "system" fn GenerateDigits2, Impl: ITLegacyCallMediaControl2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdigits: ::std::mem::MaybeUninit<::windows_core::BSTR>, digitmode: i32, lduration: i32) -> ::windows_core::HRESULT { @@ -5947,7 +5947,7 @@ impl ITLegacyCallMediaControl2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetIDAsVariant, Impl: ITLegacyCallMediaControl2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdeviceclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardeviceid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetIDAsVariant, Impl: ITLegacyCallMediaControl2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdeviceclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardeviceid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetIDAsVariant(::core::mem::transmute(&bstrdeviceclass)) { @@ -5976,14 +5976,14 @@ impl ITLegacyCallMediaControl2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITLegacyWaveSupport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsFullDuplex(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITLegacyWaveSupport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITLegacyWaveSupport_Vtbl { pub const fn new, Impl: ITLegacyWaveSupport_Impl, const OFFSET: isize>() -> ITLegacyWaveSupport_Vtbl { unsafe extern "system" fn IsFullDuplex, Impl: ITLegacyWaveSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psupport: *mut FULLDUPLEX_SUPPORT) -> ::windows_core::HRESULT { @@ -6003,8 +6003,8 @@ impl ITLegacyWaveSupport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITLocationInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn PermanentLocationID(&self) -> ::windows_core::Result; fn CountryCode(&self) -> ::windows_core::Result; @@ -6018,9 +6018,9 @@ pub trait ITLocationInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl fn TollPrefixList(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CancelCallWaitingCode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITLocationInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITLocationInfo_Vtbl { pub const fn new, Impl: ITLocationInfo_Impl, const OFFSET: isize>() -> ITLocationInfo_Vtbl { unsafe extern "system" fn PermanentLocationID, Impl: ITLocationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pllocationid: *mut i32) -> ::windows_core::HRESULT { @@ -6224,17 +6224,17 @@ impl ITMSPAddress_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITMediaControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Start(&self) -> ::windows_core::Result<()>; fn Stop(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn MediaState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITMediaControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITMediaControl_Vtbl { pub const fn new, Impl: ITMediaControl_Impl, const OFFSET: isize>() -> ITMediaControl_Vtbl { unsafe extern "system" fn Start, Impl: ITMediaControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6275,23 +6275,23 @@ impl ITMediaControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITMediaPlayback_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn SetPlayList(&self, playlistvariant: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PlayList(&self) -> ::windows_core::Result; + fn SetPlayList(&self, playlistvariant: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PlayList(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITMediaPlayback {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITMediaPlayback_Vtbl { pub const fn new, Impl: ITMediaPlayback_Impl, const OFFSET: isize>() -> ITMediaPlayback_Vtbl { - unsafe extern "system" fn SetPlayList, Impl: ITMediaPlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, playlistvariant: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPlayList, Impl: ITMediaPlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, playlistvariant: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPlayList(::core::mem::transmute(&playlistvariant)).into() } - unsafe extern "system" fn PlayList, Impl: ITMediaPlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pplaylistvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlayList, Impl: ITMediaPlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pplaylistvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PlayList() { @@ -6312,15 +6312,15 @@ impl ITMediaPlayback_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITMediaRecord_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetFileName(&self, bstrfilename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FileName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITMediaRecord {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITMediaRecord_Vtbl { pub const fn new, Impl: ITMediaRecord_Impl, const OFFSET: isize>() -> ITMediaRecord_Vtbl { unsafe extern "system" fn SetFileName, Impl: ITMediaRecord_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6349,15 +6349,15 @@ impl ITMediaRecord_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITMediaSupport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MediaTypes(&self) -> ::windows_core::Result; fn QueryMediaType(&self, lmediatype: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITMediaSupport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITMediaSupport_Vtbl { pub const fn new, Impl: ITMediaSupport_Impl, const OFFSET: isize>() -> ITMediaSupport_Vtbl { unsafe extern "system" fn MediaTypes, Impl: ITMediaSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plmediatypes: *mut i32) -> ::windows_core::HRESULT { @@ -6392,22 +6392,22 @@ impl ITMediaSupport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITMultiTrackTerminal_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn TrackTerminals(&self) -> ::windows_core::Result; + fn TrackTerminals(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateTrackTerminals(&self) -> ::windows_core::Result; fn CreateTrackTerminal(&self, mediatype: i32, terminaldirection: TERMINAL_DIRECTION) -> ::windows_core::Result; fn MediaTypesInUse(&self) -> ::windows_core::Result; fn DirectionsInUse(&self) -> ::windows_core::Result; fn RemoveTrackTerminal(&self, ptrackterminaltoremove: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITMultiTrackTerminal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITMultiTrackTerminal_Vtbl { pub const fn new, Impl: ITMultiTrackTerminal_Impl, const OFFSET: isize>() -> ITMultiTrackTerminal_Vtbl { - unsafe extern "system" fn TrackTerminals, Impl: ITMultiTrackTerminal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TrackTerminals, Impl: ITMultiTrackTerminal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TrackTerminals() { @@ -6481,16 +6481,16 @@ impl ITMultiTrackTerminal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPhone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Open(&self, privilege: PHONE_PRIVILEGE) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; - fn Addresses(&self) -> ::windows_core::Result; + fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateAddresses(&self) -> ::windows_core::Result; fn get_PhoneCapsLong(&self, pclcap: PHONECAPS_LONG) -> ::windows_core::Result; fn get_PhoneCapsString(&self, pcscap: PHONECAPS_STRING) -> ::windows_core::Result<::windows_core::BSTR>; - fn get_Terminals(&self, paddress: ::core::option::Option<&ITAddress>) -> ::windows_core::Result; + fn get_Terminals(&self, paddress: ::core::option::Option<&ITAddress>) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateTerminals(&self, paddress: ::core::option::Option<&ITAddress>) -> ::windows_core::Result; fn get_ButtonMode(&self, lbuttonid: i32) -> ::windows_core::Result; fn put_ButtonMode(&self, lbuttonid: i32, buttonmode: PHONE_BUTTON_MODE) -> ::windows_core::Result<()>; @@ -6507,20 +6507,20 @@ pub trait ITPhone_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RingVolume(&self) -> ::windows_core::Result; fn Privilege(&self) -> ::windows_core::Result; fn GetPhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER, pdwsize: *mut u32, ppphonecapsbuffer: *mut *mut u8) -> ::windows_core::Result<()>; - fn get_PhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER) -> ::windows_core::Result; + fn get_PhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER) -> ::windows_core::Result<::windows_core::VARIANT>; fn get_LampMode(&self, llampid: i32) -> ::windows_core::Result; fn put_LampMode(&self, llampid: i32, lampmode: PHONE_LAMP_MODE) -> ::windows_core::Result<()>; fn Display(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDisplay(&self, lrow: i32, lcolumn: i32, bstrdisplay: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn PreferredAddresses(&self) -> ::windows_core::Result; + fn PreferredAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePreferredAddresses(&self) -> ::windows_core::Result; fn DeviceSpecific(&self, pparams: *const u8, dwsize: u32) -> ::windows_core::Result<()>; - fn DeviceSpecificVariant(&self, vardevspecificbytearray: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeviceSpecificVariant(&self, vardevspecificbytearray: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn NegotiateExtVersion(&self, llowversion: i32, lhighversion: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPhone {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPhone_Vtbl { pub const fn new, Impl: ITPhone_Impl, const OFFSET: isize>() -> ITPhone_Vtbl { unsafe extern "system" fn Open, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, privilege: PHONE_PRIVILEGE) -> ::windows_core::HRESULT { @@ -6533,7 +6533,7 @@ impl ITPhone_Vtbl { let this = (*this).get_impl(); this.Close().into() } - unsafe extern "system" fn Addresses, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Addresses, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Addresses() { @@ -6577,7 +6577,7 @@ impl ITPhone_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Terminals, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Terminals, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Terminals(::windows_core::from_raw_borrowed(&paddress)) { @@ -6722,7 +6722,7 @@ impl ITPhone_Vtbl { let this = (*this).get_impl(); this.GetPhoneCapsBuffer(::core::mem::transmute_copy(&pcbcaps), ::core::mem::transmute_copy(&pdwsize), ::core::mem::transmute_copy(&ppphonecapsbuffer)).into() } - unsafe extern "system" fn get_PhoneCapsBuffer, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcbcaps: PHONECAPS_BUFFER, pvarbuffer: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_PhoneCapsBuffer, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcbcaps: PHONECAPS_BUFFER, pvarbuffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_PhoneCapsBuffer(::core::mem::transmute_copy(&pcbcaps)) { @@ -6765,7 +6765,7 @@ impl ITPhone_Vtbl { let this = (*this).get_impl(); this.SetDisplay(::core::mem::transmute_copy(&lrow), ::core::mem::transmute_copy(&lcolumn), ::core::mem::transmute(&bstrdisplay)).into() } - unsafe extern "system" fn PreferredAddresses, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PreferredAddresses, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PreferredAddresses() { @@ -6792,7 +6792,7 @@ impl ITPhone_Vtbl { let this = (*this).get_impl(); this.DeviceSpecific(::core::mem::transmute_copy(&pparams), ::core::mem::transmute_copy(&dwsize)).into() } - unsafe extern "system" fn DeviceSpecificVariant, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeviceSpecificVariant, Impl: ITPhone_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardevspecificbytearray: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeviceSpecificVariant(::core::mem::transmute(&vardevspecificbytearray)).into() @@ -6849,17 +6849,17 @@ impl ITPhone_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPhoneDeviceSpecificEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Phone(&self) -> ::windows_core::Result; fn lParam1(&self) -> ::windows_core::Result; fn lParam2(&self) -> ::windows_core::Result; fn lParam3(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPhoneDeviceSpecificEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPhoneDeviceSpecificEvent_Vtbl { pub const fn new, Impl: ITPhoneDeviceSpecificEvent_Impl, const OFFSET: isize>() -> ITPhoneDeviceSpecificEvent_Vtbl { unsafe extern "system" fn Phone, Impl: ITPhoneDeviceSpecificEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6918,8 +6918,8 @@ impl ITPhoneDeviceSpecificEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPhoneEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Phone(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; @@ -6931,9 +6931,9 @@ pub trait ITPhoneEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn NumberGathered(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Call(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPhoneEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPhoneEvent_Vtbl { pub const fn new, Impl: ITPhoneEvent_Impl, const OFFSET: isize>() -> ITPhoneEvent_Vtbl { unsafe extern "system" fn Phone, Impl: ITPhoneEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7052,8 +7052,8 @@ impl ITPhoneEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPluggableTerminalClassInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Company(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -7063,9 +7063,9 @@ pub trait ITPluggableTerminalClassInfo_Impl: Sized + super::super::System::Com:: fn Direction(&self) -> ::windows_core::Result; fn MediaTypes(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPluggableTerminalClassInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPluggableTerminalClassInfo_Vtbl { pub const fn new, Impl: ITPluggableTerminalClassInfo_Impl, const OFFSET: isize>() -> ITPluggableTerminalClassInfo_Vtbl { unsafe extern "system" fn Name, Impl: ITPluggableTerminalClassInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7208,15 +7208,15 @@ impl ITPluggableTerminalEventSinkRegistration_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPluggableTerminalSuperclassInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CLSID(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPluggableTerminalSuperclassInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPluggableTerminalSuperclassInfo_Vtbl { pub const fn new, Impl: ITPluggableTerminalSuperclassInfo_Impl, const OFFSET: isize>() -> ITPluggableTerminalSuperclassInfo_Vtbl { unsafe extern "system" fn Name, Impl: ITPluggableTerminalSuperclassInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7251,8 +7251,8 @@ impl ITPluggableTerminalSuperclassInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITPrivateEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Address(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; @@ -7260,9 +7260,9 @@ pub trait ITPrivateEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl fn EventCode(&self) -> ::windows_core::Result; fn EventInterface(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITPrivateEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITPrivateEvent_Vtbl { pub const fn new, Impl: ITPrivateEvent_Impl, const OFFSET: isize>() -> ITPrivateEvent_Vtbl { unsafe extern "system" fn Address, Impl: ITPrivateEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7333,16 +7333,16 @@ impl ITPrivateEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITQOSEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; fn MediaType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITQOSEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITQOSEvent_Vtbl { pub const fn new, Impl: ITQOSEvent_Impl, const OFFSET: isize>() -> ITQOSEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITQOSEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcall: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7389,8 +7389,8 @@ impl ITQOSEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetMeasurementPeriod(&self, lperiod: i32) -> ::windows_core::Result<()>; fn MeasurementPeriod(&self) -> ::windows_core::Result; @@ -7405,9 +7405,9 @@ pub trait ITQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FinalDisposition(&self) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITQueue_Vtbl { pub const fn new, Impl: ITQueue_Impl, const OFFSET: isize>() -> ITQueue_Vtbl { unsafe extern "system" fn SetMeasurementPeriod, Impl: ITQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lperiod: i32) -> ::windows_core::HRESULT { @@ -7556,15 +7556,15 @@ impl ITQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITQueueEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Queue(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITQueueEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITQueueEvent_Vtbl { pub const fn new, Impl: ITQueueEvent_Impl, const OFFSET: isize>() -> ITQueueEvent_Vtbl { unsafe extern "system" fn Queue, Impl: ITQueueEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppqueue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7599,20 +7599,20 @@ impl ITQueueEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITRendezvous_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn DefaultDirectories(&self) -> ::windows_core::Result; + fn DefaultDirectories(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateDefaultDirectories(&self) -> ::windows_core::Result; fn CreateDirectory(&self, directorytype: DIRECTORY_TYPE, pname: &::windows_core::BSTR) -> ::windows_core::Result; fn CreateDirectoryObject(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITRendezvous {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITRendezvous_Vtbl { pub const fn new, Impl: ITRendezvous_Impl, const OFFSET: isize>() -> ITRendezvous_Vtbl { - unsafe extern "system" fn DefaultDirectories, Impl: ITRendezvous_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DefaultDirectories, Impl: ITRendezvous_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DefaultDirectories() { @@ -7668,14 +7668,14 @@ impl ITRendezvous_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITRequest_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MakeCall(&self, pdestaddress: &::windows_core::BSTR, pappname: &::windows_core::BSTR, pcalledparty: &::windows_core::BSTR, pcomment: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITRequest_Vtbl { pub const fn new, Impl: ITRequest_Impl, const OFFSET: isize>() -> ITRequest_Vtbl { unsafe extern "system" fn MakeCall, Impl: ITRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdestaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, pappname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcalledparty: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7689,8 +7689,8 @@ impl ITRequest_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITRequestEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RegistrationInstance(&self) -> ::windows_core::Result; fn RequestMode(&self) -> ::windows_core::Result; @@ -7699,9 +7699,9 @@ pub trait ITRequestEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl fn CalledParty(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Comment(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITRequestEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITRequestEvent_Vtbl { pub const fn new, Impl: ITRequestEvent_Impl, const OFFSET: isize>() -> ITRequestEvent_Vtbl { unsafe extern "system" fn RegistrationInstance, Impl: ITRequestEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plregistrationinstance: *mut i32) -> ::windows_core::HRESULT { @@ -7784,8 +7784,8 @@ impl ITRequestEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITScriptableAudioFormat_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Channels(&self) -> ::windows_core::Result; fn SetChannels(&self, nnewval: i32) -> ::windows_core::Result<()>; @@ -7800,9 +7800,9 @@ pub trait ITScriptableAudioFormat_Impl: Sized + super::super::System::Com::IDisp fn FormatTag(&self) -> ::windows_core::Result; fn SetFormatTag(&self, nnewval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITScriptableAudioFormat {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITScriptableAudioFormat_Vtbl { pub const fn new, Impl: ITScriptableAudioFormat_Impl, const OFFSET: isize>() -> ITScriptableAudioFormat_Vtbl { unsafe extern "system" fn Channels, Impl: ITScriptableAudioFormat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -7921,14 +7921,14 @@ impl ITScriptableAudioFormat_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITStaticAudioTerminal_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn WaveId(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITStaticAudioTerminal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITStaticAudioTerminal_Vtbl { pub const fn new, Impl: ITStaticAudioTerminal_Impl, const OFFSET: isize>() -> ITStaticAudioTerminal_Vtbl { unsafe extern "system" fn WaveId, Impl: ITStaticAudioTerminal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plwaveid: *mut i32) -> ::windows_core::HRESULT { @@ -7948,8 +7948,8 @@ impl ITStaticAudioTerminal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MediaType(&self) -> ::windows_core::Result; fn Direction(&self) -> ::windows_core::Result; @@ -7960,11 +7960,11 @@ pub trait ITStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SelectTerminal(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; fn UnselectTerminal(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; fn EnumerateTerminals(&self) -> ::windows_core::Result; - fn Terminals(&self) -> ::windows_core::Result; + fn Terminals(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITStream_Vtbl { pub const fn new, Impl: ITStream_Impl, const OFFSET: isize>() -> ITStream_Vtbl { unsafe extern "system" fn MediaType, Impl: ITStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plmediatype: *mut i32) -> ::windows_core::HRESULT { @@ -8036,7 +8036,7 @@ impl ITStream_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Terminals, Impl: ITStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Terminals, Impl: ITStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Terminals() { @@ -8065,17 +8065,17 @@ impl ITStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITStreamControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateStream(&self, lmediatype: i32, td: TERMINAL_DIRECTION) -> ::windows_core::Result; fn RemoveStream(&self, pstream: ::core::option::Option<&ITStream>) -> ::windows_core::Result<()>; fn EnumerateStreams(&self) -> ::windows_core::Result; - fn Streams(&self) -> ::windows_core::Result; + fn Streams(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITStreamControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITStreamControl_Vtbl { pub const fn new, Impl: ITStreamControl_Impl, const OFFSET: isize>() -> ITStreamControl_Vtbl { unsafe extern "system" fn CreateStream, Impl: ITStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lmediatype: i32, td: TERMINAL_DIRECTION, ppstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8105,7 +8105,7 @@ impl ITStreamControl_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Streams, Impl: ITStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Streams, Impl: ITStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Streams() { @@ -8128,8 +8128,8 @@ impl ITStreamControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITSubStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartSubStream(&self) -> ::windows_core::Result<()>; fn PauseSubStream(&self) -> ::windows_core::Result<()>; @@ -8137,12 +8137,12 @@ pub trait ITSubStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SelectTerminal(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; fn UnselectTerminal(&self, pterminal: ::core::option::Option<&ITTerminal>) -> ::windows_core::Result<()>; fn EnumerateTerminals(&self) -> ::windows_core::Result; - fn Terminals(&self) -> ::windows_core::Result; + fn Terminals(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Stream(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITSubStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITSubStream_Vtbl { pub const fn new, Impl: ITSubStream_Impl, const OFFSET: isize>() -> ITSubStream_Vtbl { unsafe extern "system" fn StartSubStream, Impl: ITSubStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8181,7 +8181,7 @@ impl ITSubStream_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Terminals, Impl: ITSubStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Terminals, Impl: ITSubStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Terminals() { @@ -8219,17 +8219,17 @@ impl ITSubStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITSubStreamControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateSubStream(&self) -> ::windows_core::Result; fn RemoveSubStream(&self, psubstream: ::core::option::Option<&ITSubStream>) -> ::windows_core::Result<()>; fn EnumerateSubStreams(&self) -> ::windows_core::Result; - fn SubStreams(&self) -> ::windows_core::Result; + fn SubStreams(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITSubStreamControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITSubStreamControl_Vtbl { pub const fn new, Impl: ITSubStreamControl_Impl, const OFFSET: isize>() -> ITSubStreamControl_Vtbl { unsafe extern "system" fn CreateSubStream, Impl: ITSubStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsubstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8259,7 +8259,7 @@ impl ITSubStreamControl_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SubStreams, Impl: ITSubStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SubStreams, Impl: ITSubStreamControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SubStreams() { @@ -8282,29 +8282,29 @@ impl ITSubStreamControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPI_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Initialize(&self) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; - fn Addresses(&self) -> ::windows_core::Result; + fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateAddresses(&self) -> ::windows_core::Result; fn RegisterCallNotifications(&self, paddress: ::core::option::Option<&ITAddress>, fmonitor: super::super::Foundation::VARIANT_BOOL, fowner: super::super::Foundation::VARIANT_BOOL, lmediatypes: i32, lcallbackinstance: i32) -> ::windows_core::Result; fn UnregisterNotifications(&self, lregister: i32) -> ::windows_core::Result<()>; - fn CallHubs(&self) -> ::windows_core::Result; + fn CallHubs(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateCallHubs(&self) -> ::windows_core::Result; - fn SetCallHubTracking(&self, paddresses: &super::super::System::Variant::VARIANT, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; + fn SetCallHubTracking(&self, paddresses: &::windows_core::VARIANT, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn EnumeratePrivateTAPIObjects(&self) -> ::windows_core::Result; - fn PrivateTAPIObjects(&self) -> ::windows_core::Result; + fn PrivateTAPIObjects(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn RegisterRequestRecipient(&self, lregistrationinstance: i32, lrequestmode: i32, fenable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetAssistedTelephonyPriority(&self, pappfilename: &::windows_core::BSTR, fpriority: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetApplicationPriority(&self, pappfilename: &::windows_core::BSTR, lmediatype: i32, fpriority: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetEventFilter(&self, lfiltermask: i32) -> ::windows_core::Result<()>; fn EventFilter(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPI {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPI_Vtbl { pub const fn new, Impl: ITTAPI_Impl, const OFFSET: isize>() -> ITTAPI_Vtbl { unsafe extern "system" fn Initialize, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8317,7 +8317,7 @@ impl ITTAPI_Vtbl { let this = (*this).get_impl(); this.Shutdown().into() } - unsafe extern "system" fn Addresses, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Addresses, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Addresses() { @@ -8355,7 +8355,7 @@ impl ITTAPI_Vtbl { let this = (*this).get_impl(); this.UnregisterNotifications(::core::mem::transmute_copy(&lregister)).into() } - unsafe extern "system" fn CallHubs, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CallHubs, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CallHubs() { @@ -8377,7 +8377,7 @@ impl ITTAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCallHubTracking, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: super::super::System::Variant::VARIANT, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCallHubTracking, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, paddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCallHubTracking(::core::mem::transmute(&paddresses), ::core::mem::transmute_copy(&btracking)).into() @@ -8393,7 +8393,7 @@ impl ITTAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PrivateTAPIObjects, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PrivateTAPIObjects, Impl: ITTAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PrivateTAPIObjects() { @@ -8459,19 +8459,19 @@ impl ITTAPI_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPI2_Impl: Sized + ITTAPI_Impl { - fn Phones(&self) -> ::windows_core::Result; + fn Phones(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePhones(&self) -> ::windows_core::Result; fn CreateEmptyCollectionObject(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPI2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPI2_Vtbl { pub const fn new, Impl: ITTAPI2_Impl, const OFFSET: isize>() -> ITTAPI2_Vtbl { - unsafe extern "system" fn Phones, Impl: ITTAPI2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Phones, Impl: ITTAPI2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Phones() { @@ -8515,15 +8515,15 @@ impl ITTAPI2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPICallCenter_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EnumerateAgentHandlers(&self) -> ::windows_core::Result; - fn AgentHandlers(&self) -> ::windows_core::Result; + fn AgentHandlers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPICallCenter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPICallCenter_Vtbl { pub const fn new, Impl: ITTAPICallCenter_Impl, const OFFSET: isize>() -> ITTAPICallCenter_Vtbl { unsafe extern "system" fn EnumerateAgentHandlers, Impl: ITTAPICallCenter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumhandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8537,7 +8537,7 @@ impl ITTAPICallCenter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AgentHandlers, Impl: ITTAPICallCenter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AgentHandlers, Impl: ITTAPICallCenter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AgentHandlers() { @@ -8558,12 +8558,12 @@ impl ITTAPICallCenter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPIDispatchEventNotification_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPIDispatchEventNotification {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPIDispatchEventNotification_Vtbl { pub const fn new, Impl: ITTAPIDispatchEventNotification_Impl, const OFFSET: isize>() -> ITTAPIDispatchEventNotification_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8593,17 +8593,17 @@ impl ITTAPIEventNotification_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPIObjectEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TAPIObject(&self) -> ::windows_core::Result; fn Event(&self) -> ::windows_core::Result; fn Address(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPIObjectEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPIObjectEvent_Vtbl { pub const fn new, Impl: ITTAPIObjectEvent_Impl, const OFFSET: isize>() -> ITTAPIObjectEvent_Vtbl { unsafe extern "system" fn TAPIObject, Impl: ITTAPIObjectEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pptapiobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8662,14 +8662,14 @@ impl ITTAPIObjectEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTAPIObjectEvent2_Impl: Sized + ITTAPIObjectEvent_Impl { fn Phone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTAPIObjectEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTAPIObjectEvent2_Vtbl { pub const fn new, Impl: ITTAPIObjectEvent2_Impl, const OFFSET: isize>() -> ITTAPIObjectEvent2_Vtbl { unsafe extern "system" fn Phone, Impl: ITTAPIObjectEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8689,16 +8689,16 @@ impl ITTAPIObjectEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTTSTerminalEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Terminal(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; fn Error(&self) -> ::windows_core::Result<::windows_core::HRESULT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTTSTerminalEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTTSTerminalEvent_Vtbl { pub const fn new, Impl: ITTTSTerminalEvent_Impl, const OFFSET: isize>() -> ITTTSTerminalEvent_Vtbl { unsafe extern "system" fn Terminal, Impl: ITTTSTerminalEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8745,8 +8745,8 @@ impl ITTTSTerminalEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTerminal_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn State(&self) -> ::windows_core::Result; @@ -8755,9 +8755,9 @@ pub trait ITTerminal_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MediaType(&self) -> ::windows_core::Result; fn Direction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTerminal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTerminal_Vtbl { pub const fn new, Impl: ITTerminal_Impl, const OFFSET: isize>() -> ITTerminal_Vtbl { unsafe extern "system" fn Name, Impl: ITTerminal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8840,22 +8840,22 @@ impl ITTerminal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTerminalSupport_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn StaticTerminals(&self) -> ::windows_core::Result; + fn StaticTerminals(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateStaticTerminals(&self) -> ::windows_core::Result; - fn DynamicTerminalClasses(&self) -> ::windows_core::Result; + fn DynamicTerminalClasses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumerateDynamicTerminalClasses(&self) -> ::windows_core::Result; fn CreateTerminal(&self, pterminalclass: &::windows_core::BSTR, lmediatype: i32, direction: TERMINAL_DIRECTION) -> ::windows_core::Result; fn GetDefaultStaticTerminal(&self, lmediatype: i32, direction: TERMINAL_DIRECTION) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTerminalSupport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTerminalSupport_Vtbl { pub const fn new, Impl: ITTerminalSupport_Impl, const OFFSET: isize>() -> ITTerminalSupport_Vtbl { - unsafe extern "system" fn StaticTerminals, Impl: ITTerminalSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StaticTerminals, Impl: ITTerminalSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StaticTerminals() { @@ -8877,7 +8877,7 @@ impl ITTerminalSupport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DynamicTerminalClasses, Impl: ITTerminalSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DynamicTerminalClasses, Impl: ITTerminalSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DynamicTerminalClasses() { @@ -8935,20 +8935,20 @@ impl ITTerminalSupport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITTerminalSupport2_Impl: Sized + ITTerminalSupport_Impl { - fn PluggableSuperclasses(&self) -> ::windows_core::Result; + fn PluggableSuperclasses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePluggableSuperclasses(&self) -> ::windows_core::Result; - fn get_PluggableTerminalClasses(&self, bstrterminalsuperclass: &::windows_core::BSTR, lmediatype: i32) -> ::windows_core::Result; + fn get_PluggableTerminalClasses(&self, bstrterminalsuperclass: &::windows_core::BSTR, lmediatype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumeratePluggableTerminalClasses(&self, iidterminalsuperclass: &::windows_core::GUID, lmediatype: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITTerminalSupport2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITTerminalSupport2_Vtbl { pub const fn new, Impl: ITTerminalSupport2_Impl, const OFFSET: isize>() -> ITTerminalSupport2_Vtbl { - unsafe extern "system" fn PluggableSuperclasses, Impl: ITTerminalSupport2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PluggableSuperclasses, Impl: ITTerminalSupport2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PluggableSuperclasses() { @@ -8970,7 +8970,7 @@ impl ITTerminalSupport2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_PluggableTerminalClasses, Impl: ITTerminalSupport2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrterminalsuperclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_PluggableTerminalClasses, Impl: ITTerminalSupport2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrterminalsuperclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_PluggableTerminalClasses(::core::mem::transmute(&bstrterminalsuperclass), ::core::mem::transmute_copy(&lmediatype)) { @@ -9004,17 +9004,17 @@ impl ITTerminalSupport2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITToneDetectionEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Call(&self) -> ::windows_core::Result; fn AppSpecific(&self) -> ::windows_core::Result; fn TickCount(&self) -> ::windows_core::Result; fn CallbackInstance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITToneDetectionEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITToneDetectionEvent_Vtbl { pub const fn new, Impl: ITToneDetectionEvent_Impl, const OFFSET: isize>() -> ITToneDetectionEvent_Vtbl { unsafe extern "system" fn Call, Impl: ITToneDetectionEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcallinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9073,16 +9073,16 @@ impl ITToneDetectionEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITToneTerminalEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Terminal(&self) -> ::windows_core::Result; fn Call(&self) -> ::windows_core::Result; fn Error(&self) -> ::windows_core::Result<::windows_core::HRESULT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITToneTerminalEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITToneTerminalEvent_Vtbl { pub const fn new, Impl: ITToneTerminalEvent_Impl, const OFFSET: isize>() -> ITToneTerminalEvent_Vtbl { unsafe extern "system" fn Terminal, Impl: ITToneTerminalEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Devices/Tapi/mod.rs b/crates/libs/windows/src/Windows/Win32/Devices/Tapi/mod.rs index 1f6a25fba0..94013a0c33 100644 --- a/crates/libs/windows/src/Windows/Win32/Devices/Tapi/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Devices/Tapi/mod.rs @@ -2338,9 +2338,7 @@ pub struct IEnumTerminalClass_Vtbl { ::windows_core::imp::interface_hierarchy!(IMcastAddressAllocation, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMcastAddressAllocation { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Scopes(&self) -> ::windows_core::Result { + pub unsafe fn Scopes(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Scopes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2384,15 +2382,16 @@ impl IMcastAddressAllocation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateLeaseInfo)(::windows_core::Interface::as_raw(self), leasestarttime, leasestoptime, dwnumaddresses, ppaddresses, prequestid.into_param().abi(), pserveraddress.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateLeaseInfoFromVariant(&self, leasestarttime: f64, leasestoptime: f64, vaddresses: super::super::System::Variant::VARIANT, prequestid: P0, pserveraddress: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateLeaseInfoFromVariant(&self, leasestarttime: f64, leasestoptime: f64, vaddresses: P0, prequestid: P1, pserveraddress: P2) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateLeaseInfoFromVariant)(::windows_core::Interface::as_raw(self), leasestarttime, leasestoptime, ::core::mem::transmute(vaddresses), prequestid.into_param().abi(), pserveraddress.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateLeaseInfoFromVariant)(::windows_core::Interface::as_raw(self), leasestarttime, leasestoptime, vaddresses.into_param().abi(), prequestid.into_param().abi(), pserveraddress.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -2400,10 +2399,7 @@ impl IMcastAddressAllocation { #[doc(hidden)] pub struct IMcastAddressAllocation_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Scopes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Scopes: usize, + pub Scopes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateScopes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenummcastscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub RequestAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pscope: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, numaddresses: i32, ppleaseresponse: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2421,9 +2417,9 @@ pub struct IMcastAddressAllocation_Vtbl { pub CreateLeaseInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, dwnumaddresses: u32, ppaddresses: *const ::windows_core::PCWSTR, prequestid: ::windows_core::PCWSTR, pserveraddress: ::windows_core::PCWSTR, ppreleaserequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateLeaseInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateLeaseInfoFromVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, vaddresses: super::super::System::Variant::VARIANT, prequestid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pserveraddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppreleaserequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateLeaseInfoFromVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, leasestarttime: f64, leasestoptime: f64, vaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>, prequestid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pserveraddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppreleaserequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateLeaseInfoFromVariant: usize, } #[cfg(feature = "Win32_System_Com")] @@ -2467,9 +2463,7 @@ impl IMcastLeaseInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TTL)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Addresses(&self) -> ::windows_core::Result { + pub unsafe fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Addresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2491,10 +2485,7 @@ pub struct IMcastLeaseInfo_Vtbl { pub AddressCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, pub ServerAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppaddress: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub TTL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pttl: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Addresses: usize, + pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumaddresses: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -2559,9 +2550,7 @@ impl ITACDGroup { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateQueues)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Queues(&self) -> ::windows_core::Result { + pub unsafe fn Queues(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Queues)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2573,10 +2562,7 @@ pub struct ITACDGroup_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub EnumerateQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumqueue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Queues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Queues: usize, + pub Queues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2720,9 +2706,7 @@ impl ITAddress { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateCall)(::windows_core::Interface::as_raw(self), pdestaddress.into_param().abi(), laddresstype, lmediatypes, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Calls(&self) -> ::windows_core::Result { + pub unsafe fn Calls(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Calls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2792,10 +2776,7 @@ pub struct ITAddress_Vtbl { pub CreateCall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdestaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, laddresstype: i32, lmediatypes: i32, ppcall: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateCall: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Calls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Calls: usize, + pub Calls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcallenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DialableAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdialableaddress: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -2853,9 +2834,7 @@ impl ITAddress2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CreateCall)(::windows_core::Interface::as_raw(self), pdestaddress.into_param().abi(), laddresstype, lmediatypes, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Calls(&self) -> ::windows_core::Result { + pub unsafe fn Calls(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Calls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2908,9 +2887,7 @@ impl ITAddress2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DoNotDisturb)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Phones(&self) -> ::windows_core::Result { + pub unsafe fn Phones(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Phones)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2927,9 +2904,7 @@ impl ITAddress2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPhoneFromTerminal)(::windows_core::Interface::as_raw(self), pterminal.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PreferredPhones(&self) -> ::windows_core::Result { + pub unsafe fn PreferredPhones(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PreferredPhones)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2955,13 +2930,14 @@ impl ITAddress2 { { (::windows_core::Interface::vtable(self).DeviceSpecific)(::windows_core::Interface::as_raw(self), pcall.into_param().abi(), pparams, dwsize).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeviceSpecificVariant(&self, pcall: P0, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn DeviceSpecificVariant(&self, pcall: P0, vardevspecificbytearray: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeviceSpecificVariant)(::windows_core::Interface::as_raw(self), pcall.into_param().abi(), ::core::mem::transmute(vardevspecificbytearray)).ok() + (::windows_core::Interface::vtable(self).DeviceSpecificVariant)(::windows_core::Interface::as_raw(self), pcall.into_param().abi(), vardevspecificbytearray.into_param().abi()).ok() } pub unsafe fn NegotiateExtVersion(&self, llowversion: i32, lhighversion: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2973,19 +2949,13 @@ impl ITAddress2 { #[doc(hidden)] pub struct ITAddress2_Vtbl { pub base__: ITAddress_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Phones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Phones: usize, + pub Phones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePhones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetPhoneFromTerminal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminal: *mut ::core::ffi::c_void, ppphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetPhoneFromTerminal: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PreferredPhones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PreferredPhones: usize, + pub PreferredPhones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePreferredPhones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub get_EventFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tapievent: TAPI_EVENT, lsubevent: i32, penable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub put_EventFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tapievent: TAPI_EVENT, lsubevent: i32, benable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -2993,9 +2963,9 @@ pub struct ITAddress2_Vtbl { pub DeviceSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcall: *mut ::core::ffi::c_void, pparams: *const u8, dwsize: u32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DeviceSpecific: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeviceSpecificVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcall: *mut ::core::ffi::c_void, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub DeviceSpecificVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcall: *mut ::core::ffi::c_void, vardevspecificbytearray: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] DeviceSpecificVariant: usize, pub NegotiateExtVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, llowversion: i32, lhighversion: i32, plextversion: *mut i32) -> ::windows_core::HRESULT, } @@ -3018,9 +2988,7 @@ impl ITAddressCapabilities { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_AddressCapabilityString)(::windows_core::Interface::as_raw(self), addresscapstring, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CallTreatments(&self) -> ::windows_core::Result { + pub unsafe fn CallTreatments(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CallTreatments)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3028,9 +2996,7 @@ impl ITAddressCapabilities { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateCallTreatments)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CompletionMessages(&self) -> ::windows_core::Result { + pub unsafe fn CompletionMessages(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CompletionMessages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3038,9 +3004,7 @@ impl ITAddressCapabilities { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateCompletionMessages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeviceClasses(&self) -> ::windows_core::Result { + pub unsafe fn DeviceClasses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DeviceClasses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3056,20 +3020,11 @@ pub struct ITAddressCapabilities_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub get_AddressCapability: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, addresscap: ADDRESS_CAPABILITY, plcapability: *mut i32) -> ::windows_core::HRESULT, pub get_AddressCapabilityString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, addresscapstring: ADDRESS_CAPABILITY_STRING, ppcapabilitystring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CallTreatments: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CallTreatments: usize, + pub CallTreatments: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateCallTreatments: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumcalltreatment: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CompletionMessages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CompletionMessages: usize, + pub CompletionMessages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateCompletionMessages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumcompletionmessage: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeviceClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeviceClasses: usize, + pub DeviceClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateDeviceClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumdeviceclass: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -3198,9 +3153,7 @@ impl ITAddressTranslation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateLocations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Locations(&self) -> ::windows_core::Result { + pub unsafe fn Locations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Locations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3208,9 +3161,7 @@ impl ITAddressTranslation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateCallingCards)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CallingCards(&self) -> ::windows_core::Result { + pub unsafe fn CallingCards(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CallingCards)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3226,15 +3177,9 @@ pub struct ITAddressTranslation_Vtbl { TranslateAddress: usize, pub TranslateDialog: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndowner: isize, paddressin: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub EnumerateLocations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumlocation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Locations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Locations: usize, + pub Locations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateCallingCards: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumcallingcard: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CallingCards: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CallingCards: usize, + pub CallingCards: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3367,9 +3312,7 @@ impl ITAgent { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TotalWrapUpTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AgentSessions(&self) -> ::windows_core::Result { + pub unsafe fn AgentSessions(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AgentSessions)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3404,10 +3347,7 @@ pub struct ITAgent_Vtbl { pub TotalACDTalkTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pltalktime: *mut i32) -> ::windows_core::HRESULT, pub TotalACDCallTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcalltime: *mut i32) -> ::windows_core::HRESULT, pub TotalWrapUpTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plwrapuptime: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AgentSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AgentSessions: usize, + pub AgentSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3481,15 +3421,11 @@ impl ITAgentHandler { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateUsableAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ACDGroups(&self) -> ::windows_core::Result { + pub unsafe fn ACDGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ACDGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UsableAddresses(&self) -> ::windows_core::Result { + pub unsafe fn UsableAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).UsableAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3510,14 +3446,8 @@ pub struct ITAgentHandler_Vtbl { CreateAgentWithID: usize, pub EnumerateACDGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumacdgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EnumerateUsableAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ACDGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ACDGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UsableAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UsableAddresses: usize, + pub ACDGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub UsableAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3903,9 +3833,7 @@ impl ITAutomatedPhoneControl { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateSelectedCalls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelectedCalls(&self) -> ::windows_core::Result { + pub unsafe fn SelectedCalls(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelectedCalls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3952,10 +3880,7 @@ pub struct ITAutomatedPhoneControl_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] UnselectCall: usize, pub EnumerateSelectedCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcallenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelectedCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelectedCalls: usize, + pub SelectedCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4297,9 +4222,7 @@ impl ITCallHub { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateCalls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Calls(&self) -> ::windows_core::Result { + pub unsafe fn Calls(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Calls)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4319,10 +4242,7 @@ pub struct ITCallHub_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EnumerateCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumcall: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Calls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcalls: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Calls: usize, + pub Calls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcalls: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub NumCalls: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcalls: *mut i32) -> ::windows_core::HRESULT, pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstate: *mut CALLHUB_STATE) -> ::windows_core::HRESULT, } @@ -4417,16 +4337,15 @@ impl ITCallInfo { { (::windows_core::Interface::vtable(self).put_CallInfoString)(::windows_core::Interface::as_raw(self), callinfostring, pcallinfostring.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result { + pub unsafe fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).put_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, ::core::mem::transmute(pcallinfobuffer)).ok() + pub unsafe fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).put_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, pcallinfobuffer.into_param().abi()).ok() } pub unsafe fn GetCallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pdwsize: *mut u32, ppcallinfobuffer: *mut *mut u8) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, pdwsize, ppcallinfobuffer).ok() @@ -4457,14 +4376,8 @@ pub struct ITCallInfo_Vtbl { pub put_CallInfoLong: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfolong: CALLINFO_LONG, lcallinfolongval: i32) -> ::windows_core::HRESULT, pub get_CallInfoString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfostring: CALLINFO_STRING, ppcallinfostring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub put_CallInfoString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfostring: CALLINFO_STRING, pcallinfostring: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_CallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, ppcallinfobuffer: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_CallInfoBuffer: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_CallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_CallInfoBuffer: usize, + pub get_CallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, ppcallinfobuffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_CallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, pdwsize: *mut u32, ppcallinfobuffer: *mut *mut u8) -> ::windows_core::HRESULT, pub SetCallInfoBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, callinfobuffer: CALLINFO_BUFFER, dwsize: u32, pcallinfobuffer: *const u8) -> ::windows_core::HRESULT, pub ReleaseUserUserInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4517,16 +4430,15 @@ impl ITCallInfo2 { { (::windows_core::Interface::vtable(self).base__.put_CallInfoString)(::windows_core::Interface::as_raw(self), callinfostring, pcallinfostring.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result { + pub unsafe fn get_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.get_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.put_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, ::core::mem::transmute(pcallinfobuffer)).ok() + pub unsafe fn put_CallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pcallinfobuffer: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.put_CallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, pcallinfobuffer.into_param().abi()).ok() } pub unsafe fn GetCallInfoBuffer(&self, callinfobuffer: CALLINFO_BUFFER, pdwsize: *mut u32, ppcallinfobuffer: *mut *mut u8) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetCallInfoBuffer)(::windows_core::Interface::as_raw(self), callinfobuffer, pdwsize, ppcallinfobuffer).ok() @@ -4806,9 +4718,7 @@ impl ITCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -4823,10 +4733,7 @@ impl ITCollection { pub struct ITCollection_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnewenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -4844,9 +4751,7 @@ impl ITCollection2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -4854,10 +4759,8 @@ impl ITCollection2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, index: i32, pvariant: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), index, pvariant).ok() + pub unsafe fn Add(&self, index: i32, pvariant: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), index, ::core::mem::transmute(pvariant)).ok() } pub unsafe fn Remove(&self, index: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index).ok() @@ -4868,10 +4771,7 @@ impl ITCollection2 { #[doc(hidden)] pub struct ITCollection2_Vtbl { pub base__: ITCollection_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5194,9 +5094,7 @@ impl ITDirectory { { (::windows_core::Interface::vtable(self).DeleteDirectoryObject)(::windows_core::Interface::as_raw(self), pdirectoryobject.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_DirectoryObjects(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: P0) -> ::windows_core::Result + pub unsafe fn get_DirectoryObjects(&self, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -5240,10 +5138,7 @@ pub struct ITDirectory_Vtbl { pub DeleteDirectoryObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdirectoryobject: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DeleteDirectoryObject: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_DirectoryObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_DirectoryObjects: usize, + pub get_DirectoryObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateDirectoryObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, directoryobjecttype: DIRECTORY_OBJECT_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppenumobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5271,9 +5166,7 @@ impl ITDirectoryObject { { (::windows_core::Interface::vtable(self).SetName)(::windows_core::Interface::as_raw(self), pname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_DialableAddrs(&self, dwaddresstype: i32) -> ::windows_core::Result { + pub unsafe fn get_DialableAddrs(&self, dwaddresstype: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_DialableAddrs)(::windows_core::Interface::as_raw(self), dwaddresstype, &mut result__).from_abi(result__) } @@ -5304,10 +5197,7 @@ pub struct ITDirectoryObject_Vtbl { pub ObjectType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pobjecttype: *mut DIRECTORY_OBJECT_TYPE) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_DialableAddrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwaddresstype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_DialableAddrs: usize, + pub get_DialableAddrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwaddresstype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateDialableAddrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwaddresstype: u32, ppenumdialableaddrs: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub SecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsecdes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5966,9 +5856,7 @@ impl ITLegacyCallMediaControl2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateCustomToneObject)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetIDAsVariant(&self, bstrdeviceclass: P0) -> ::windows_core::Result + pub unsafe fn GetIDAsVariant(&self, bstrdeviceclass: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -6002,10 +5890,7 @@ pub struct ITLegacyCallMediaControl2_Vtbl { pub CreateCustomToneObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcustomtone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateCustomToneObject: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetIDAsVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdeviceclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardeviceid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetIDAsVariant: usize, + pub GetIDAsVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdeviceclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardeviceid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6192,14 +6077,13 @@ pub struct ITMediaControl_Vtbl { ::windows_core::imp::interface_hierarchy!(ITMediaPlayback, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ITMediaPlayback { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPlayList(&self, playlistvariant: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPlayList)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(playlistvariant)).ok() + pub unsafe fn SetPlayList(&self, playlistvariant: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPlayList)(::windows_core::Interface::as_raw(self), playlistvariant.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PlayList(&self) -> ::windows_core::Result { + pub unsafe fn PlayList(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlayList)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6209,14 +6093,8 @@ impl ITMediaPlayback { #[doc(hidden)] pub struct ITMediaPlayback_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPlayList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, playlistvariant: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPlayList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PlayList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pplaylistvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PlayList: usize, + pub SetPlayList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, playlistvariant: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PlayList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pplaylistvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6287,9 +6165,7 @@ pub struct ITMediaSupport_Vtbl { ::windows_core::imp::interface_hierarchy!(ITMultiTrackTerminal, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ITMultiTrackTerminal { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TrackTerminals(&self) -> ::windows_core::Result { + pub unsafe fn TrackTerminals(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TrackTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6325,10 +6201,7 @@ impl ITMultiTrackTerminal { #[doc(hidden)] pub struct ITMultiTrackTerminal_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TrackTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TrackTerminals: usize, + pub TrackTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateTrackTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateTrackTerminal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mediatype: i32, terminaldirection: TERMINAL_DIRECTION, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -6358,9 +6231,7 @@ impl ITPhone { pub unsafe fn Close(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Close)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Addresses(&self) -> ::windows_core::Result { + pub unsafe fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Addresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6376,9 +6247,9 @@ impl ITPhone { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_PhoneCapsString)(::windows_core::Interface::as_raw(self), pcscap, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Terminals(&self, paddress: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Terminals(&self, paddress: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -6450,9 +6321,7 @@ impl ITPhone { pub unsafe fn GetPhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER, pdwsize: *mut u32, ppphonecapsbuffer: *mut *mut u8) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetPhoneCapsBuffer)(::windows_core::Interface::as_raw(self), pcbcaps, pdwsize, ppphonecapsbuffer).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_PhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER) -> ::windows_core::Result { + pub unsafe fn get_PhoneCapsBuffer(&self, pcbcaps: PHONECAPS_BUFFER) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_PhoneCapsBuffer)(::windows_core::Interface::as_raw(self), pcbcaps, &mut result__).from_abi(result__) } @@ -6473,9 +6342,7 @@ impl ITPhone { { (::windows_core::Interface::vtable(self).SetDisplay)(::windows_core::Interface::as_raw(self), lrow, lcolumn, bstrdisplay.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PreferredAddresses(&self) -> ::windows_core::Result { + pub unsafe fn PreferredAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PreferredAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6486,10 +6353,11 @@ impl ITPhone { pub unsafe fn DeviceSpecific(&self, pparams: *const u8, dwsize: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeviceSpecific)(::windows_core::Interface::as_raw(self), pparams, dwsize).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeviceSpecificVariant(&self, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeviceSpecificVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardevspecificbytearray)).ok() + pub unsafe fn DeviceSpecificVariant(&self, vardevspecificbytearray: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeviceSpecificVariant)(::windows_core::Interface::as_raw(self), vardevspecificbytearray.into_param().abi()).ok() } pub unsafe fn NegotiateExtVersion(&self, llowversion: i32, lhighversion: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6503,16 +6371,13 @@ pub struct ITPhone_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, privilege: PHONE_PRIVILEGE) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Addresses: usize, + pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub get_PhoneCapsLong: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pclcap: PHONECAPS_LONG, plcapability: *mut i32) -> ::windows_core::HRESULT, pub get_PhoneCapsString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcscap: PHONECAPS_STRING, ppcapability: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Terminals: usize, #[cfg(feature = "Win32_System_Com")] pub EnumerateTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, ppenumterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -6533,24 +6398,15 @@ pub struct ITPhone_Vtbl { pub RingVolume: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plringvolume: *mut i32) -> ::windows_core::HRESULT, pub Privilege: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprivilege: *mut PHONE_PRIVILEGE) -> ::windows_core::HRESULT, pub GetPhoneCapsBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbcaps: PHONECAPS_BUFFER, pdwsize: *mut u32, ppphonecapsbuffer: *mut *mut u8) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_PhoneCapsBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbcaps: PHONECAPS_BUFFER, pvarbuffer: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_PhoneCapsBuffer: usize, + pub get_PhoneCapsBuffer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbcaps: PHONECAPS_BUFFER, pvarbuffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub get_LampMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, llampid: i32, plampmode: *mut PHONE_LAMP_MODE) -> ::windows_core::HRESULT, pub put_LampMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, llampid: i32, lampmode: PHONE_LAMP_MODE) -> ::windows_core::HRESULT, pub Display: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdisplay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lrow: i32, lcolumn: i32, bstrdisplay: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PreferredAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PreferredAddresses: usize, + pub PreferredAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePreferredAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DeviceSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pparams: *const u8, dwsize: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeviceSpecificVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardevspecificbytearray: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeviceSpecificVariant: usize, + pub DeviceSpecificVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardevspecificbytearray: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub NegotiateExtVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, llowversion: i32, lhighversion: i32, plextversion: *mut i32) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -7010,9 +6866,7 @@ pub struct ITQueueEvent_Vtbl { ::windows_core::imp::interface_hierarchy!(ITRendezvous, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ITRendezvous { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DefaultDirectories(&self) -> ::windows_core::Result { + pub unsafe fn DefaultDirectories(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DefaultDirectories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7044,10 +6898,7 @@ impl ITRendezvous { #[doc(hidden)] pub struct ITRendezvous_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DefaultDirectories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DefaultDirectories: usize, + pub DefaultDirectories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateDefaultDirectories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumdirectory: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateDirectory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, directorytype: DIRECTORY_TYPE, pname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppdir: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7281,9 +7132,7 @@ impl ITStream { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Terminals(&self) -> ::windows_core::Result { + pub unsafe fn Terminals(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Terminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7308,10 +7157,7 @@ pub struct ITStream_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] UnselectTerminal: usize, pub EnumerateTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Terminals: usize, + pub Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7342,9 +7188,7 @@ impl ITStreamControl { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateStreams)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Streams(&self) -> ::windows_core::Result { + pub unsafe fn Streams(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Streams)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7363,10 +7207,7 @@ pub struct ITStreamControl_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] RemoveStream: usize, pub EnumerateStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Streams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Streams: usize, + pub Streams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7408,9 +7249,7 @@ impl ITSubStream { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Terminals(&self) -> ::windows_core::Result { + pub unsafe fn Terminals(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Terminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7438,10 +7277,7 @@ pub struct ITSubStream_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] UnselectTerminal: usize, pub EnumerateTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminals: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Terminals: usize, + pub Terminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminals: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Stream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppitstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -7476,9 +7312,7 @@ impl ITSubStreamControl { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateSubStreams)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SubStreams(&self) -> ::windows_core::Result { + pub unsafe fn SubStreams(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SubStreams)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7497,10 +7331,7 @@ pub struct ITSubStreamControl_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] RemoveSubStream: usize, pub EnumerateSubStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumsubstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SubStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SubStreams: usize, + pub SubStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7519,9 +7350,7 @@ impl ITTAPI { pub unsafe fn Shutdown(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Shutdown)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Addresses(&self) -> ::windows_core::Result { + pub unsafe fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Addresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7543,9 +7372,7 @@ impl ITTAPI { pub unsafe fn UnregisterNotifications(&self, lregister: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).UnregisterNotifications)(::windows_core::Interface::as_raw(self), lregister).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CallHubs(&self) -> ::windows_core::Result { + pub unsafe fn CallHubs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CallHubs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7553,13 +7380,12 @@ impl ITTAPI { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateCallHubs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCallHubTracking(&self, paddresses: super::super::System::Variant::VARIANT, btracking: P0) -> ::windows_core::Result<()> + pub unsafe fn SetCallHubTracking(&self, paddresses: P0, btracking: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).SetCallHubTracking)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(paddresses), btracking.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).SetCallHubTracking)(::windows_core::Interface::as_raw(self), paddresses.into_param().abi(), btracking.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7567,9 +7393,7 @@ impl ITTAPI { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumeratePrivateTAPIObjects)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrivateTAPIObjects(&self) -> ::windows_core::Result { + pub unsafe fn PrivateTAPIObjects(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PrivateTAPIObjects)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7608,33 +7432,21 @@ pub struct ITTAPI_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Initialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Shutdown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Addresses: usize, + pub Addresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumaddress: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub RegisterCallNotifications: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddress: *mut ::core::ffi::c_void, fmonitor: super::super::Foundation::VARIANT_BOOL, fowner: super::super::Foundation::VARIANT_BOOL, lmediatypes: i32, lcallbackinstance: i32, plregister: *mut i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] RegisterCallNotifications: usize, pub UnregisterNotifications: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lregister: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CallHubs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CallHubs: usize, + pub CallHubs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateCallHubs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumcallhub: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCallHubTracking: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: super::super::System::Variant::VARIANT, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCallHubTracking: usize, + pub SetCallHubTracking: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>, btracking: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub EnumeratePrivateTAPIObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumunknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] EnumeratePrivateTAPIObjects: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PrivateTAPIObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PrivateTAPIObjects: usize, + pub PrivateTAPIObjects: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RegisterRequestRecipient: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lregistrationinstance: i32, lrequestmode: i32, fenable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetAssistedTelephonyPriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pappfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, fpriority: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetApplicationPriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pappfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, fpriority: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -7658,9 +7470,7 @@ impl ITTAPI2 { pub unsafe fn Shutdown(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Shutdown)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Addresses(&self) -> ::windows_core::Result { + pub unsafe fn Addresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Addresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7682,9 +7492,7 @@ impl ITTAPI2 { pub unsafe fn UnregisterNotifications(&self, lregister: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.UnregisterNotifications)(::windows_core::Interface::as_raw(self), lregister).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CallHubs(&self) -> ::windows_core::Result { + pub unsafe fn CallHubs(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CallHubs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7692,13 +7500,12 @@ impl ITTAPI2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EnumerateCallHubs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCallHubTracking(&self, paddresses: super::super::System::Variant::VARIANT, btracking: P0) -> ::windows_core::Result<()> + pub unsafe fn SetCallHubTracking(&self, paddresses: P0, btracking: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.SetCallHubTracking)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(paddresses), btracking.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.SetCallHubTracking)(::windows_core::Interface::as_raw(self), paddresses.into_param().abi(), btracking.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7706,9 +7513,7 @@ impl ITTAPI2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EnumeratePrivateTAPIObjects)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrivateTAPIObjects(&self) -> ::windows_core::Result { + pub unsafe fn PrivateTAPIObjects(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PrivateTAPIObjects)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7739,9 +7544,7 @@ impl ITTAPI2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EventFilter)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Phones(&self) -> ::windows_core::Result { + pub unsafe fn Phones(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Phones)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7761,10 +7564,7 @@ impl ITTAPI2 { #[doc(hidden)] pub struct ITTAPI2_Vtbl { pub base__: ITTAPI_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Phones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Phones: usize, + pub Phones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphones: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePhones: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumphone: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateEmptyCollectionObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7786,9 +7586,7 @@ impl ITTAPICallCenter { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateAgentHandlers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AgentHandlers(&self) -> ::windows_core::Result { + pub unsafe fn AgentHandlers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AgentHandlers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7799,10 +7597,7 @@ impl ITTAPICallCenter { pub struct ITTAPICallCenter_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub EnumerateAgentHandlers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumhandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AgentHandlers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AgentHandlers: usize, + pub AgentHandlers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -8040,9 +7835,7 @@ pub struct ITTerminal_Vtbl { ::windows_core::imp::interface_hierarchy!(ITTerminalSupport, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ITTerminalSupport { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StaticTerminals(&self) -> ::windows_core::Result { + pub unsafe fn StaticTerminals(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StaticTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8050,9 +7843,7 @@ impl ITTerminalSupport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateStaticTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DynamicTerminalClasses(&self) -> ::windows_core::Result { + pub unsafe fn DynamicTerminalClasses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DynamicTerminalClasses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8081,15 +7872,9 @@ impl ITTerminalSupport { #[doc(hidden)] pub struct ITTerminalSupport_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StaticTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StaticTerminals: usize, + pub StaticTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateStaticTerminals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppterminalenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DynamicTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DynamicTerminalClasses: usize, + pub DynamicTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateDynamicTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppterminalclassenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateTerminal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pterminalclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, direction: TERMINAL_DIRECTION, ppterminal: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -8111,9 +7896,7 @@ pub struct ITTerminalSupport_Vtbl { ::windows_core::imp::interface_hierarchy!(ITTerminalSupport2, ::windows_core::IUnknown, super::super::System::Com::IDispatch, ITTerminalSupport); #[cfg(feature = "Win32_System_Com")] impl ITTerminalSupport2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StaticTerminals(&self) -> ::windows_core::Result { + pub unsafe fn StaticTerminals(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.StaticTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8121,9 +7904,7 @@ impl ITTerminalSupport2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EnumerateStaticTerminals)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DynamicTerminalClasses(&self) -> ::windows_core::Result { + pub unsafe fn DynamicTerminalClasses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DynamicTerminalClasses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8146,9 +7927,7 @@ impl ITTerminalSupport2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetDefaultStaticTerminal)(::windows_core::Interface::as_raw(self), lmediatype, direction, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PluggableSuperclasses(&self) -> ::windows_core::Result { + pub unsafe fn PluggableSuperclasses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PluggableSuperclasses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8156,9 +7935,7 @@ impl ITTerminalSupport2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumeratePluggableSuperclasses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_PluggableTerminalClasses(&self, bstrterminalsuperclass: P0, lmediatype: i32) -> ::windows_core::Result + pub unsafe fn get_PluggableTerminalClasses(&self, bstrterminalsuperclass: P0, lmediatype: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -8175,15 +7952,9 @@ impl ITTerminalSupport2 { #[doc(hidden)] pub struct ITTerminalSupport2_Vtbl { pub base__: ITTerminalSupport_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PluggableSuperclasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PluggableSuperclasses: usize, + pub PluggableSuperclasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePluggableSuperclasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsuperclassenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_PluggableTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrterminalsuperclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_PluggableTerminalClasses: usize, + pub get_PluggableTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrterminalsuperclass: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmediatype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumeratePluggableTerminalClasses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iidterminalsuperclass: ::windows_core::GUID, lmediatype: i32, ppclassenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] diff --git a/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/impl.rs b/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/impl.rs index 24e745ed07..0995be546c 100644 --- a/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/impl.rs @@ -1596,20 +1596,16 @@ impl IWICDevelopRawNotificationCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IWICEnumMetadataItem_Impl: Sized { - fn Next(&self, celt: u32, rgeltschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, celt: u32, rgeltschema: *mut ::windows_core::PROPVARIANT, rgeltid: *mut ::windows_core::PROPVARIANT, rgeltvalue: *mut ::windows_core::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWICEnumMetadataItem {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IWICEnumMetadataItem_Vtbl { pub const fn new, Impl: IWICEnumMetadataItem_Impl, const OFFSET: isize>() -> IWICEnumMetadataItem_Vtbl { - unsafe extern "system" fn Next, Impl: IWICEnumMetadataItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgeltschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IWICEnumMetadataItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgeltschema: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rgeltid: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rgeltvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgeltschema), ::core::mem::transmute_copy(&rgeltid), ::core::mem::transmute_copy(&rgeltvalue), ::core::mem::transmute_copy(&pceltfetched)).into() @@ -2439,17 +2435,17 @@ impl IWICMetadataHandlerInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWICMetadataQueryReader_Impl: Sized { fn GetContainerFormat(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetLocation(&self, cchmaxlength: u32, wznamespace: &::windows_core::PWSTR, pcchactuallength: *mut u32) -> ::windows_core::Result<()>; - fn GetMetadataByName(&self, wzname: &::windows_core::PCWSTR, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetMetadataByName(&self, wzname: &::windows_core::PCWSTR, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetEnumerator(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWICMetadataQueryReader {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWICMetadataQueryReader_Vtbl { pub const fn new, Impl: IWICMetadataQueryReader_Impl, const OFFSET: isize>() -> IWICMetadataQueryReader_Vtbl { unsafe extern "system" fn GetContainerFormat, Impl: IWICMetadataQueryReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidcontainerformat: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -2468,7 +2464,7 @@ impl IWICMetadataQueryReader_Vtbl { let this = (*this).get_impl(); this.GetLocation(::core::mem::transmute_copy(&cchmaxlength), ::core::mem::transmute(&wznamespace), ::core::mem::transmute_copy(&pcchactuallength)).into() } - unsafe extern "system" fn GetMetadataByName, Impl: IWICMetadataQueryReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetMetadataByName, Impl: IWICMetadataQueryReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetMetadataByName(::core::mem::transmute(&wzname), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -2496,18 +2492,18 @@ impl IWICMetadataQueryReader_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWICMetadataQueryWriter_Impl: Sized + IWICMetadataQueryReader_Impl { - fn SetMetadataByName(&self, wzname: &::windows_core::PCWSTR, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetMetadataByName(&self, wzname: &::windows_core::PCWSTR, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn RemoveMetadataByName(&self, wzname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWICMetadataQueryWriter {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWICMetadataQueryWriter_Vtbl { pub const fn new, Impl: IWICMetadataQueryWriter_Impl, const OFFSET: isize>() -> IWICMetadataQueryWriter_Vtbl { - unsafe extern "system" fn SetMetadataByName, Impl: IWICMetadataQueryWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetMetadataByName, Impl: IWICMetadataQueryWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetMetadataByName(::core::mem::transmute(&wzname), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -2527,19 +2523,15 @@ impl IWICMetadataQueryWriter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IWICMetadataReader_Impl: Sized { fn GetMetadataFormat(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetMetadataHandlerInfo(&self) -> ::windows_core::Result; fn GetCount(&self) -> ::windows_core::Result; - fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut ::windows_core::PROPVARIANT, pvarid: *mut ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetEnumerator(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWICMetadataReader {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IWICMetadataReader_Vtbl { pub const fn new, Impl: IWICMetadataReader_Impl, const OFFSET: isize>() -> IWICMetadataReader_Vtbl { unsafe extern "system" fn GetMetadataFormat, Impl: IWICMetadataReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidmetadataformat: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -2575,12 +2567,12 @@ impl IWICMetadataReader_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValueByIndex, Impl: IWICMetadataReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValueByIndex, Impl: IWICMetadataReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValueByIndex(::core::mem::transmute_copy(&nindex), ::core::mem::transmute_copy(&pvarschema), ::core::mem::transmute_copy(&pvarid), ::core::mem::transmute_copy(&pvarvalue)).into() } - unsafe extern "system" fn GetValue, Impl: IWICMetadataReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IWICMetadataReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValue(::core::mem::transmute_copy(&pvarschema), ::core::mem::transmute_copy(&pvarid), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -2660,30 +2652,26 @@ impl IWICMetadataReaderInfo_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IWICMetadataWriter_Impl: Sized + IWICMetadataReader_Impl { - fn SetValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn SetValueByIndex(&self, nindex: u32, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn RemoveValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetValueByIndex(&self, nindex: u32, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn RemoveValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn RemoveValueByIndex(&self, nindex: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWICMetadataWriter {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IWICMetadataWriter_Vtbl { pub const fn new, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>() -> IWICMetadataWriter_Vtbl { - unsafe extern "system" fn SetValue, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&pvarschema), ::core::mem::transmute_copy(&pvarid), ::core::mem::transmute_copy(&pvarvalue)).into() } - unsafe extern "system" fn SetValueByIndex, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValueByIndex, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValueByIndex(::core::mem::transmute_copy(&nindex), ::core::mem::transmute_copy(&pvarschema), ::core::mem::transmute_copy(&pvarid), ::core::mem::transmute_copy(&pvarvalue)).into() } - unsafe extern "system" fn RemoveValue, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveValue, Impl: IWICMetadataWriter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveValue(::core::mem::transmute_copy(&pvarschema), ::core::mem::transmute_copy(&pvarid)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/mod.rs b/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/mod.rs index 61fb0c853e..8fe6c9f0ad 100644 --- a/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Graphics/Imaging/mod.rs @@ -1500,10 +1500,8 @@ pub struct IWICDevelopRawNotificationCallback_Vtbl { ::windows_core::imp::com_interface!(IWICEnumMetadataItem, IWICEnumMetadataItem_Vtbl, 0xdc2bb46d_3f07_481e_8625_220c4aedbb33); ::windows_core::imp::interface_hierarchy!(IWICEnumMetadataItem, ::windows_core::IUnknown); impl IWICEnumMetadataItem { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, celt: u32, rgeltschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), celt, rgeltschema, rgeltid, rgeltvalue, pceltfetched).ok() + pub unsafe fn Next(&self, celt: u32, rgeltschema: *mut ::windows_core::PROPVARIANT, rgeltid: *mut ::windows_core::PROPVARIANT, rgeltvalue: *mut ::windows_core::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), celt, ::core::mem::transmute(rgeltschema), ::core::mem::transmute(rgeltid), ::core::mem::transmute(rgeltvalue), pceltfetched).ok() } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Skip)(::windows_core::Interface::as_raw(self), celt).ok() @@ -1520,10 +1518,7 @@ impl IWICEnumMetadataItem { #[doc(hidden)] pub struct IWICEnumMetadataItem_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgeltschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, rgeltvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgeltschema: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rgeltid: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rgeltvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppienummetadataitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2095,13 +2090,11 @@ impl IWICMetadataQueryReader { pub unsafe fn GetLocation(&self, wznamespace: &mut [u16], pcchactuallength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetLocation)(::windows_core::Interface::as_raw(self), wznamespace.len().try_into().unwrap(), ::core::mem::transmute(wznamespace.as_ptr()), pcchactuallength).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetMetadataByName(&self, wzname: P0, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetMetadataByName(&self, wzname: P0, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).GetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).GetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2116,10 +2109,7 @@ pub struct IWICMetadataQueryReader_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetContainerFormat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidcontainerformat: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cchmaxlength: u32, wznamespace: ::windows_core::PWSTR, pcchactuallength: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetMetadataByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetMetadataByName: usize, + pub GetMetadataByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetEnumerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppienumstring: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2135,13 +2125,11 @@ impl IWICMetadataQueryWriter { pub unsafe fn GetLocation(&self, wznamespace: &mut [u16], pcchactuallength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetLocation)(::windows_core::Interface::as_raw(self), wznamespace.len().try_into().unwrap(), ::core::mem::transmute(wznamespace.as_ptr()), pcchactuallength).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetMetadataByName(&self, wzname: P0, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetMetadataByName(&self, wzname: P0, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.GetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).base__.GetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2149,13 +2137,11 @@ impl IWICMetadataQueryWriter { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEnumerator)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetMetadataByName(&self, wzname: P0, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetMetadataByName(&self, wzname: P0, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).SetMetadataByName)(::windows_core::Interface::as_raw(self), wzname.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn RemoveMetadataByName(&self, wzname: P0) -> ::windows_core::Result<()> where @@ -2168,10 +2154,7 @@ impl IWICMetadataQueryWriter { #[doc(hidden)] pub struct IWICMetadataQueryWriter_Vtbl { pub base__: IWICMetadataQueryReader_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetMetadataByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetMetadataByName: usize, + pub SetMetadataByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub RemoveMetadataByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wzname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWICMetadataReader, IWICMetadataReader_Vtbl, 0x9204fe99_d8fc_4fd5_a001_9536b067a899); @@ -2189,15 +2172,11 @@ impl IWICMetadataReader { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut ::windows_core::PROPVARIANT, pvarid: *mut ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn GetValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn GetEnumerator(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2211,14 +2190,8 @@ pub struct IWICMetadataReader_Vtbl { pub GetMetadataFormat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidmetadataformat: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetMetadataHandlerInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppihandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pccount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValueByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValueByIndex: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValueByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetEnumerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppienummetadata: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWICMetadataReaderInfo, IWICMetadataReaderInfo_Vtbl, 0xeebf1f5b_07c1_4447_a3ab_22acaf78a804); @@ -2320,34 +2293,24 @@ impl IWICMetadataWriter { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn GetValueByIndex(&self, nindex: u32, pvarschema: *mut ::windows_core::PROPVARIANT, pvarid: *mut ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn GetValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn GetEnumerator(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEnumerator)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn SetValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetValueByIndex(&self, nindex: u32, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, pvarschema, pvarid, pvarvalue).ok() + pub unsafe fn SetValueByIndex(&self, nindex: u32, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT, pvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValueByIndex)(::windows_core::Interface::as_raw(self), nindex, ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid), ::core::mem::transmute(pvarvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveValue(&self, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveValue)(::windows_core::Interface::as_raw(self), pvarschema, pvarid).ok() + pub unsafe fn RemoveValue(&self, pvarschema: *const ::windows_core::PROPVARIANT, pvarid: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).RemoveValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarschema), ::core::mem::transmute(pvarid)).ok() } pub unsafe fn RemoveValueByIndex(&self, nindex: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RemoveValueByIndex)(::windows_core::Interface::as_raw(self), nindex).ok() @@ -2357,18 +2320,9 @@ impl IWICMetadataWriter { #[doc(hidden)] pub struct IWICMetadataWriter_Vtbl { pub base__: IWICMetadataReader_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetValueByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetValueByIndex: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub RemoveValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarid: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - RemoveValue: usize, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetValueByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub RemoveValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarschema: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub RemoveValueByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWICMetadataWriterInfo, IWICMetadataWriterInfo_Vtbl, 0xb22e3fba_3925_4323_b5c1_9ebfc430f236); diff --git a/crates/libs/windows/src/Windows/Win32/Graphics/Printing/impl.rs b/crates/libs/windows/src/Windows/Win32/Graphics/Printing/impl.rs index 6c11bf2efa..08f0b73d82 100644 --- a/crates/libs/windows/src/Windows/Win32/Graphics/Printing/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Graphics/Printing/impl.rs @@ -1499,16 +1499,16 @@ impl IPrintJob_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintJobCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn GetAt(&self, ulindex: u32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintJobCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintJobCollection_Vtbl { pub const fn new, Impl: IPrintJobCollection_Impl, const OFFSET: isize>() -> IPrintJobCollection_Vtbl { unsafe extern "system" fn Count, Impl: IPrintJobCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulcount: *mut u32) -> ::windows_core::HRESULT { @@ -1879,24 +1879,20 @@ impl IPrintPipelineProgressReport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IPrintPipelinePropertyBag_Impl: Sized { - fn AddProperty(&self, pszname: &::windows_core::PCWSTR, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetProperty(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn AddProperty(&self, pszname: &::windows_core::PCWSTR, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn DeleteProperty(&self, pszname: &::windows_core::PCWSTR) -> super::super::Foundation::BOOL; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPrintPipelinePropertyBag {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IPrintPipelinePropertyBag_Vtbl { pub const fn new, Impl: IPrintPipelinePropertyBag_Impl, const OFFSET: isize>() -> IPrintPipelinePropertyBag_Vtbl { - unsafe extern "system" fn AddProperty, Impl: IPrintPipelinePropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddProperty, Impl: IPrintPipelinePropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddProperty(::core::mem::transmute(&pszname), ::core::mem::transmute_copy(&pvar)).into() } - unsafe extern "system" fn GetProperty, Impl: IPrintPipelinePropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IPrintPipelinePropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&pszname)) { @@ -2011,15 +2007,15 @@ impl IPrintReadStreamFactory_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaAsyncOperation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Start(&self) -> ::windows_core::Result<()>; fn Cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaAsyncOperation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaAsyncOperation_Vtbl { pub const fn new, Impl: IPrintSchemaAsyncOperation_Impl, const OFFSET: isize>() -> IPrintSchemaAsyncOperation_Vtbl { unsafe extern "system" fn Start, Impl: IPrintSchemaAsyncOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2042,14 +2038,14 @@ impl IPrintSchemaAsyncOperation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaAsyncOperationEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Completed(&self, pticket: ::core::option::Option<&IPrintSchemaTicket>, hroperation: ::windows_core::HRESULT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaAsyncOperationEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaAsyncOperationEvent_Vtbl { pub const fn new, Impl: IPrintSchemaAsyncOperationEvent_Impl, const OFFSET: isize>() -> IPrintSchemaAsyncOperationEvent_Vtbl { unsafe extern "system" fn Completed, Impl: IPrintSchemaAsyncOperationEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pticket: *mut ::core::ffi::c_void, hroperation: ::windows_core::HRESULT) -> ::windows_core::HRESULT { @@ -2063,8 +2059,8 @@ impl IPrintSchemaAsyncOperationEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaCapabilities_Impl: Sized + IPrintSchemaElement_Impl { fn GetFeatureByKeyName(&self, bstrkeyname: &::windows_core::BSTR) -> ::windows_core::Result; fn GetFeature(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; @@ -2074,9 +2070,9 @@ pub trait IPrintSchemaCapabilities_Impl: Sized + IPrintSchemaElement_Impl { fn GetSelectedOptionInPrintTicket(&self, pfeature: ::core::option::Option<&IPrintSchemaFeature>) -> ::windows_core::Result; fn GetOptions(&self, pfeature: ::core::option::Option<&IPrintSchemaFeature>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaCapabilities {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaCapabilities_Vtbl { pub const fn new, Impl: IPrintSchemaCapabilities_Impl, const OFFSET: isize>() -> IPrintSchemaCapabilities_Vtbl { unsafe extern "system" fn GetFeatureByKeyName, Impl: IPrintSchemaCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrkeyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppfeature: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2171,14 +2167,14 @@ impl IPrintSchemaCapabilities_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaCapabilities2_Impl: Sized + IPrintSchemaCapabilities_Impl { fn GetParameterDefinition(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaCapabilities2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaCapabilities2_Vtbl { pub const fn new, Impl: IPrintSchemaCapabilities2_Impl, const OFFSET: isize>() -> IPrintSchemaCapabilities2_Vtbl { unsafe extern "system" fn GetParameterDefinition, Impl: IPrintSchemaCapabilities2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnamespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppparameterdefinition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2198,14 +2194,14 @@ impl IPrintSchemaCapabilities2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaDisplayableElement_Impl: Sized + IPrintSchemaElement_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaDisplayableElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaDisplayableElement_Vtbl { pub const fn new, Impl: IPrintSchemaDisplayableElement_Impl, const OFFSET: isize>() -> IPrintSchemaDisplayableElement_Vtbl { unsafe extern "system" fn DisplayName, Impl: IPrintSchemaDisplayableElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrdisplayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2225,16 +2221,16 @@ impl IPrintSchemaDisplayableElement_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaElement_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn XmlNode(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn NamespaceUri(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaElement_Vtbl { pub const fn new, Impl: IPrintSchemaElement_Impl, const OFFSET: isize>() -> IPrintSchemaElement_Vtbl { unsafe extern "system" fn XmlNode, Impl: IPrintSchemaElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppxmlnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2281,8 +2277,8 @@ impl IPrintSchemaElement_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaFeature_Impl: Sized + IPrintSchemaDisplayableElement_Impl { fn SelectedOption(&self) -> ::windows_core::Result; fn SetSelectedOption(&self, poption: ::core::option::Option<&IPrintSchemaOption>) -> ::windows_core::Result<()>; @@ -2290,9 +2286,9 @@ pub trait IPrintSchemaFeature_Impl: Sized + IPrintSchemaDisplayableElement_Impl fn GetOption(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; fn DisplayUI(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaFeature {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaFeature_Vtbl { pub const fn new, Impl: IPrintSchemaFeature_Impl, const OFFSET: isize>() -> IPrintSchemaFeature_Vtbl { unsafe extern "system" fn SelectedOption, Impl: IPrintSchemaFeature_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppoption: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2357,14 +2353,14 @@ impl IPrintSchemaFeature_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaNUpOption_Impl: Sized + IPrintSchemaOption_Impl { fn PagesPerSheet(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaNUpOption {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaNUpOption_Vtbl { pub const fn new, Impl: IPrintSchemaNUpOption_Impl, const OFFSET: isize>() -> IPrintSchemaNUpOption_Vtbl { unsafe extern "system" fn PagesPerSheet, Impl: IPrintSchemaNUpOption_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulpagespersheet: *mut u32) -> ::windows_core::HRESULT { @@ -2384,16 +2380,16 @@ impl IPrintSchemaNUpOption_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaOption_Impl: Sized + IPrintSchemaDisplayableElement_Impl { fn Selected(&self) -> ::windows_core::Result; fn Constrained(&self) -> ::windows_core::Result; fn GetPropertyValue(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaOption {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaOption_Vtbl { pub const fn new, Impl: IPrintSchemaOption_Impl, const OFFSET: isize>() -> IPrintSchemaOption_Vtbl { unsafe extern "system" fn Selected, Impl: IPrintSchemaOption_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbisselected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -2440,16 +2436,16 @@ impl IPrintSchemaOption_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaOptionCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn GetAt(&self, ulindex: u32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaOptionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaOptionCollection_Vtbl { pub const fn new, Impl: IPrintSchemaOptionCollection_Impl, const OFFSET: isize>() -> IPrintSchemaOptionCollection_Vtbl { unsafe extern "system" fn Count, Impl: IPrintSchemaOptionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulcount: *mut u32) -> ::windows_core::HRESULT { @@ -2496,8 +2492,8 @@ impl IPrintSchemaOptionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaPageImageableSize_Impl: Sized + IPrintSchemaElement_Impl { fn ImageableSizeWidthInMicrons(&self) -> ::windows_core::Result; fn ImageableSizeHeightInMicrons(&self) -> ::windows_core::Result; @@ -2506,9 +2502,9 @@ pub trait IPrintSchemaPageImageableSize_Impl: Sized + IPrintSchemaElement_Impl { fn ExtentWidthInMicrons(&self) -> ::windows_core::Result; fn ExtentHeightInMicrons(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaPageImageableSize {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaPageImageableSize_Vtbl { pub const fn new, Impl: IPrintSchemaPageImageableSize_Impl, const OFFSET: isize>() -> IPrintSchemaPageImageableSize_Vtbl { unsafe extern "system" fn ImageableSizeWidthInMicrons, Impl: IPrintSchemaPageImageableSize_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulimageablesizewidth: *mut u32) -> ::windows_core::HRESULT { @@ -2591,15 +2587,15 @@ impl IPrintSchemaPageImageableSize_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaPageMediaSizeOption_Impl: Sized + IPrintSchemaOption_Impl { fn WidthInMicrons(&self) -> ::windows_core::Result; fn HeightInMicrons(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaPageMediaSizeOption {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaPageMediaSizeOption_Vtbl { pub const fn new, Impl: IPrintSchemaPageMediaSizeOption_Impl, const OFFSET: isize>() -> IPrintSchemaPageMediaSizeOption_Vtbl { unsafe extern "system" fn WidthInMicrons, Impl: IPrintSchemaPageMediaSizeOption_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulwidth: *mut u32) -> ::windows_core::HRESULT { @@ -2634,8 +2630,8 @@ impl IPrintSchemaPageMediaSizeOption_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaParameterDefinition_Impl: Sized + IPrintSchemaDisplayableElement_Impl { fn UserInputRequired(&self) -> ::windows_core::Result; fn UnitType(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2643,9 +2639,9 @@ pub trait IPrintSchemaParameterDefinition_Impl: Sized + IPrintSchemaDisplayableE fn RangeMin(&self) -> ::windows_core::Result; fn RangeMax(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaParameterDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaParameterDefinition_Vtbl { pub const fn new, Impl: IPrintSchemaParameterDefinition_Impl, const OFFSET: isize>() -> IPrintSchemaParameterDefinition_Vtbl { unsafe extern "system" fn UserInputRequired, Impl: IPrintSchemaParameterDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbisrequired: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -2716,18 +2712,18 @@ impl IPrintSchemaParameterDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaParameterInitializer_Impl: Sized + IPrintSchemaElement_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaParameterInitializer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaParameterInitializer_Vtbl { pub const fn new, Impl: IPrintSchemaParameterInitializer_Impl, const OFFSET: isize>() -> IPrintSchemaParameterInitializer_Vtbl { - unsafe extern "system" fn Value, Impl: IPrintSchemaParameterInitializer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IPrintSchemaParameterInitializer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -2738,7 +2734,7 @@ impl IPrintSchemaParameterInitializer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IPrintSchemaParameterInitializer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IPrintSchemaParameterInitializer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&pvar)).into() @@ -2753,8 +2749,8 @@ impl IPrintSchemaParameterInitializer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaTicket_Impl: Sized + IPrintSchemaElement_Impl { fn GetFeatureByKeyName(&self, bstrkeyname: &::windows_core::BSTR) -> ::windows_core::Result; fn GetFeature(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; @@ -2765,9 +2761,9 @@ pub trait IPrintSchemaTicket_Impl: Sized + IPrintSchemaElement_Impl { fn JobCopiesAllDocuments(&self) -> ::windows_core::Result; fn SetJobCopiesAllDocuments(&self, uljobcopiesalldocuments: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaTicket {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaTicket_Vtbl { pub const fn new, Impl: IPrintSchemaTicket_Impl, const OFFSET: isize>() -> IPrintSchemaTicket_Vtbl { unsafe extern "system" fn GetFeatureByKeyName, Impl: IPrintSchemaTicket_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrkeyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppfeature: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2862,14 +2858,14 @@ impl IPrintSchemaTicket_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintSchemaTicket2_Impl: Sized + IPrintSchemaTicket_Impl { fn GetParameterInitializer(&self, bstrname: &::windows_core::BSTR, bstrnamespaceuri: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintSchemaTicket2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintSchemaTicket2_Vtbl { pub const fn new, Impl: IPrintSchemaTicket2_Impl, const OFFSET: isize>() -> IPrintSchemaTicket2_Vtbl { unsafe extern "system" fn GetParameterInitializer, Impl: IPrintSchemaTicket2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnamespaceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppparameterinitializer: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3108,17 +3104,17 @@ impl IPrinterExtensionAsyncOperation_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterExtensionContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn PrinterQueue(&self) -> ::windows_core::Result; fn PrintSchemaTicket(&self) -> ::windows_core::Result; fn DriverProperties(&self) -> ::windows_core::Result; fn UserProperties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterExtensionContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterExtensionContext_Vtbl { pub const fn new, Impl: IPrinterExtensionContext_Impl, const OFFSET: isize>() -> IPrinterExtensionContext_Vtbl { unsafe extern "system" fn PrinterQueue, Impl: IPrinterExtensionContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppqueue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3177,16 +3173,16 @@ impl IPrinterExtensionContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterExtensionContextCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn GetAt(&self, ulindex: u32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterExtensionContextCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterExtensionContextCollection_Vtbl { pub const fn new, Impl: IPrinterExtensionContextCollection_Impl, const OFFSET: isize>() -> IPrinterExtensionContextCollection_Vtbl { unsafe extern "system" fn Count, Impl: IPrinterExtensionContextCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulcount: *mut u32) -> ::windows_core::HRESULT { @@ -3233,15 +3229,15 @@ impl IPrinterExtensionContextCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterExtensionEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnDriverEvent(&self, peventargs: ::core::option::Option<&IPrinterExtensionEventArgs>) -> ::windows_core::Result<()>; fn OnPrinterQueuesEnumerated(&self, pcontextcollection: ::core::option::Option<&IPrinterExtensionContextCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterExtensionEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterExtensionEvent_Vtbl { pub const fn new, Impl: IPrinterExtensionEvent_Impl, const OFFSET: isize>() -> IPrinterExtensionEvent_Vtbl { unsafe extern "system" fn OnDriverEvent, Impl: IPrinterExtensionEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventargs: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3264,8 +3260,8 @@ impl IPrinterExtensionEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterExtensionEventArgs_Impl: Sized + IPrinterExtensionContext_Impl { fn BidiNotification(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ReasonId(&self) -> ::windows_core::Result<::windows_core::GUID>; @@ -3275,9 +3271,9 @@ pub trait IPrinterExtensionEventArgs_Impl: Sized + IPrinterExtensionContext_Impl fn WindowModal(&self) -> ::windows_core::Result; fn WindowParent(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterExtensionEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterExtensionEventArgs_Vtbl { pub const fn new, Impl: IPrinterExtensionEventArgs_Impl, const OFFSET: isize>() -> IPrinterExtensionEventArgs_Vtbl { unsafe extern "system" fn BidiNotification, Impl: IPrinterExtensionEventArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrbidinotification: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3399,15 +3395,15 @@ impl IPrinterExtensionManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterExtensionRequest_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Cancel(&self, hrstatus: ::windows_core::HRESULT, bstrlogmessage: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Complete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterExtensionRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterExtensionRequest_Vtbl { pub const fn new, Impl: IPrinterExtensionRequest_Impl, const OFFSET: isize>() -> IPrinterExtensionRequest_Vtbl { unsafe extern "system" fn Cancel, Impl: IPrinterExtensionRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hrstatus: ::windows_core::HRESULT, bstrlogmessage: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3430,8 +3426,8 @@ impl IPrinterExtensionRequest_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterPropertyBag_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetBool(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn SetBool(&self, bstrname: &::windows_core::BSTR, bvalue: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; @@ -3444,9 +3440,9 @@ pub trait IPrinterPropertyBag_Impl: Sized + super::super::System::Com::IDispatch fn GetReadStream(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn GetWriteStream(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterPropertyBag {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterPropertyBag_Vtbl { pub const fn new, Impl: IPrinterPropertyBag_Impl, const OFFSET: isize>() -> IPrinterPropertyBag_Vtbl { unsafe extern "system" fn GetBool, Impl: IPrinterPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbvalue: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -3547,17 +3543,17 @@ impl IPrinterPropertyBag_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterQueue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SendBidiQuery(&self, bstrbidiquery: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetProperties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterQueue_Vtbl { pub const fn new, Impl: IPrinterQueue_Impl, const OFFSET: isize>() -> IPrinterQueue_Vtbl { unsafe extern "system" fn Handle, Impl: IPrinterQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phprinter: *mut super::super::Foundation::HANDLE) -> ::windows_core::HRESULT { @@ -3610,15 +3606,15 @@ impl IPrinterQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterQueue2_Impl: Sized + IPrinterQueue_Impl { fn SendBidiSetRequestAsync(&self, bstrbidirequest: &::windows_core::BSTR, pcallback: ::core::option::Option<&IPrinterBidiSetRequestCallback>) -> ::windows_core::Result; fn GetPrinterQueueView(&self, ulviewoffset: u32, ulviewsize: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterQueue2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterQueue2_Vtbl { pub const fn new, Impl: IPrinterQueue2_Impl, const OFFSET: isize>() -> IPrinterQueue2_Vtbl { unsafe extern "system" fn SendBidiSetRequestAsync, Impl: IPrinterQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbidirequest: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcallback: *mut ::core::ffi::c_void, ppasyncoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3653,14 +3649,14 @@ impl IPrinterQueue2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterQueueEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnBidiResponseReceived(&self, bstrresponse: &::windows_core::BSTR, hrstatus: ::windows_core::HRESULT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterQueueEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterQueueEvent_Vtbl { pub const fn new, Impl: IPrinterQueueEvent_Impl, const OFFSET: isize>() -> IPrinterQueueEvent_Vtbl { unsafe extern "system" fn OnBidiResponseReceived, Impl: IPrinterQueueEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrresponse: ::std::mem::MaybeUninit<::windows_core::BSTR>, hrstatus: ::windows_core::HRESULT) -> ::windows_core::HRESULT { @@ -3677,14 +3673,14 @@ impl IPrinterQueueEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterQueueView_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetViewRange(&self, ulviewoffset: u32, ulviewsize: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterQueueView {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterQueueView_Vtbl { pub const fn new, Impl: IPrinterQueueView_Impl, const OFFSET: isize>() -> IPrinterQueueView_Vtbl { unsafe extern "system" fn SetViewRange, Impl: IPrinterQueueView_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ulviewoffset: u32, ulviewsize: u32) -> ::windows_core::HRESULT { @@ -3698,14 +3694,14 @@ impl IPrinterQueueView_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterQueueViewEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnChanged(&self, pcollection: ::core::option::Option<&IPrintJobCollection>, ulviewoffset: u32, ulviewsize: u32, ulcountjobsinprintqueue: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterQueueViewEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterQueueViewEvent_Vtbl { pub const fn new, Impl: IPrinterQueueViewEvent_Impl, const OFFSET: isize>() -> IPrinterQueueViewEvent_Vtbl { unsafe extern "system" fn OnChanged, Impl: IPrinterQueueViewEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcollection: *mut ::core::ffi::c_void, ulviewoffset: u32, ulviewsize: u32, ulcountjobsinprintqueue: u32) -> ::windows_core::HRESULT { @@ -3719,16 +3715,16 @@ impl IPrinterQueueViewEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterScriptContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DriverProperties(&self) -> ::windows_core::Result; fn QueueProperties(&self) -> ::windows_core::Result; fn UserProperties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterScriptContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterScriptContext_Vtbl { pub const fn new, Impl: IPrinterScriptContext_Impl, const OFFSET: isize>() -> IPrinterScriptContext_Vtbl { unsafe extern "system" fn DriverProperties, Impl: IPrinterScriptContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pppropertybag: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3775,8 +3771,8 @@ impl IPrinterScriptContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterScriptablePropertyBag_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetBool(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn SetBool(&self, bstrname: &::windows_core::BSTR, bvalue: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; @@ -3789,9 +3785,9 @@ pub trait IPrinterScriptablePropertyBag_Impl: Sized + super::super::System::Com: fn GetReadStream(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn GetWriteStream(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterScriptablePropertyBag {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterScriptablePropertyBag_Vtbl { pub const fn new, Impl: IPrinterScriptablePropertyBag_Impl, const OFFSET: isize>() -> IPrinterScriptablePropertyBag_Vtbl { unsafe extern "system" fn GetBool, Impl: IPrinterScriptablePropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbvalue: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -3898,14 +3894,14 @@ impl IPrinterScriptablePropertyBag_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterScriptablePropertyBag2_Impl: Sized + IPrinterScriptablePropertyBag_Impl { fn GetReadStreamAsXML(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterScriptablePropertyBag2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterScriptablePropertyBag2_Vtbl { pub const fn new, Impl: IPrinterScriptablePropertyBag2_Impl, const OFFSET: isize>() -> IPrinterScriptablePropertyBag2_Vtbl { unsafe extern "system" fn GetReadStreamAsXML, Impl: IPrinterScriptablePropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppxmlnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3925,15 +3921,15 @@ impl IPrinterScriptablePropertyBag2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterScriptableSequentialStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Read(&self, cbread: i32) -> ::windows_core::Result; fn Write(&self, parray: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterScriptableSequentialStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterScriptableSequentialStream_Vtbl { pub const fn new, Impl: IPrinterScriptableSequentialStream_Impl, const OFFSET: isize>() -> IPrinterScriptableSequentialStream_Vtbl { unsafe extern "system" fn Read, Impl: IPrinterScriptableSequentialStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cbread: i32, pparray: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3968,16 +3964,16 @@ impl IPrinterScriptableSequentialStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrinterScriptableStream_Impl: Sized + IPrinterScriptableSequentialStream_Impl { fn Commit(&self) -> ::windows_core::Result<()>; fn Seek(&self, loffset: i32, streamseek: super::super::System::Com::STREAM_SEEK) -> ::windows_core::Result; fn SetSize(&self, lsize: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrinterScriptableStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrinterScriptableStream_Vtbl { pub const fn new, Impl: IPrinterScriptableStream_Impl, const OFFSET: isize>() -> IPrinterScriptableStream_Vtbl { unsafe extern "system" fn Commit, Impl: IPrinterScriptableStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Graphics/Printing/mod.rs b/crates/libs/windows/src/Windows/Win32/Graphics/Printing/mod.rs index 399b586542..d6ddb8210d 100644 --- a/crates/libs/windows/src/Windows/Win32/Graphics/Printing/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Graphics/Printing/mod.rs @@ -3804,17 +3804,13 @@ pub struct IPrintPipelineProgressReport_Vtbl { ::windows_core::imp::com_interface!(IPrintPipelinePropertyBag, IPrintPipelinePropertyBag_Vtbl, 0x8b8c99dc_7892_4a95_8a04_57422e9fbb47); ::windows_core::imp::interface_hierarchy!(IPrintPipelinePropertyBag, ::windows_core::IUnknown); impl IPrintPipelinePropertyBag { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddProperty(&self, pszname: P0, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddProperty(&self, pszname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).AddProperty)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).AddProperty)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, pszname: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, pszname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -3832,14 +3828,8 @@ impl IPrintPipelinePropertyBag { #[doc(hidden)] pub struct IPrintPipelinePropertyBag_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, + pub AddProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DeleteProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR) -> super::super::Foundation::BOOL, } ::windows_core::imp::com_interface!(IPrintPreviewDxgiPackageTarget, IPrintPreviewDxgiPackageTarget_Vtbl, 0x1a6dd0ad_1e2a_4e99_a5ba_91f17818290e); @@ -4652,16 +4642,12 @@ impl IPrintSchemaParameterInitializer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.NamespaceUri)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), pvar).ok() + pub unsafe fn SetValue(&self, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4669,14 +4655,8 @@ impl IPrintSchemaParameterInitializer { #[doc(hidden)] pub struct IPrintSchemaParameterInitializer_Vtbl { pub base__: IPrintSchemaElement_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( diff --git a/crates/libs/windows/src/Windows/Win32/Media/Audio/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/Audio/impl.rs index afee7fff02..6c39d2de79 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/Audio/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/Audio/impl.rs @@ -1839,20 +1839,20 @@ impl IDeviceTopology_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IMMDevice_Impl: Sized { - fn Activate(&self, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; + fn Activate(&self, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const ::windows_core::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn OpenPropertyStore(&self, stgmaccess: super::super::System::Com::STGM) -> ::windows_core::Result; fn GetId(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IMMDevice {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IMMDevice_Vtbl { pub const fn new, Impl: IMMDevice_Impl, const OFFSET: isize>() -> IMMDevice_Vtbl { - unsafe extern "system" fn Activate, Impl: IMMDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Activate, Impl: IMMDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Activate(::core::mem::transmute_copy(&iid), ::core::mem::transmute_copy(&dwclsctx), ::core::mem::transmute_copy(&pactivationparams), ::core::mem::transmute_copy(&ppinterface)).into() @@ -1902,17 +1902,13 @@ impl IMMDevice_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMMDeviceActivator_Impl: Sized { - fn Activate(&self, iid: *const ::windows_core::GUID, pdevice: ::core::option::Option<&IMMDevice>, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; + fn Activate(&self, iid: *const ::windows_core::GUID, pdevice: ::core::option::Option<&IMMDevice>, pactivationparams: *const ::windows_core::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMMDeviceActivator {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMMDeviceActivator_Vtbl { pub const fn new, Impl: IMMDeviceActivator_Impl, const OFFSET: isize>() -> IMMDeviceActivator_Vtbl { - unsafe extern "system" fn Activate, Impl: IMMDeviceActivator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, pdevice: *mut ::core::ffi::c_void, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Activate, Impl: IMMDeviceActivator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, pdevice: *mut ::core::ffi::c_void, pactivationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Activate(::core::mem::transmute_copy(&iid), ::windows_core::from_raw_borrowed(&pdevice), ::core::mem::transmute_copy(&pactivationparams), ::core::mem::transmute_copy(&ppinterface)).into() @@ -2464,8 +2460,6 @@ impl ISimpleAudioVolume_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait ISpatialAudioClient_Impl: Sized { fn GetStaticObjectPosition(&self, r#type: AudioObjectType, x: *mut f32, y: *mut f32, z: *mut f32) -> ::windows_core::Result<()>; fn GetNativeStaticObjectTypeMask(&self) -> ::windows_core::Result; @@ -2473,12 +2467,10 @@ pub trait ISpatialAudioClient_Impl: Sized { fn GetSupportedAudioObjectFormatEnumerator(&self) -> ::windows_core::Result; fn GetMaxFrameCount(&self, objectformat: *const WAVEFORMATEX) -> ::windows_core::Result; fn IsAudioObjectFormatSupported(&self, objectformat: *const WAVEFORMATEX) -> ::windows_core::Result<()>; - fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn ActivateSpatialAudioStream(&self, activationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; + fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn ActivateSpatialAudioStream(&self, activationparams: *const ::windows_core::PROPVARIANT, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISpatialAudioClient {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ISpatialAudioClient_Vtbl { pub const fn new, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>() -> ISpatialAudioClient_Vtbl { unsafe extern "system" fn GetStaticObjectPosition, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: AudioObjectType, x: *mut f32, y: *mut f32, z: *mut f32) -> ::windows_core::HRESULT { @@ -2535,12 +2527,12 @@ impl ISpatialAudioClient_Vtbl { let this = (*this).get_impl(); this.IsAudioObjectFormatSupported(::core::mem::transmute_copy(&objectformat)).into() } - unsafe extern "system" fn IsSpatialAudioStreamAvailable, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsSpatialAudioStreamAvailable, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.IsSpatialAudioStreamAvailable(::core::mem::transmute_copy(&streamuuid), ::core::mem::transmute_copy(&auxiliaryinfo)).into() } - unsafe extern "system" fn ActivateSpatialAudioStream, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, activationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ActivateSpatialAudioStream, Impl: ISpatialAudioClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, activationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ActivateSpatialAudioStream(::core::mem::transmute_copy(&activationparams), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&stream)).into() @@ -2561,15 +2553,11 @@ impl ISpatialAudioClient_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait ISpatialAudioClient2_Impl: Sized + ISpatialAudioClient_Impl { fn IsOffloadCapable(&self, category: AUDIO_STREAM_CATEGORY) -> ::windows_core::Result; fn GetMaxFrameCountForCategory(&self, category: AUDIO_STREAM_CATEGORY, offloadenabled: super::super::Foundation::BOOL, objectformat: *const WAVEFORMATEX) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISpatialAudioClient2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ISpatialAudioClient2_Vtbl { pub const fn new, Impl: ISpatialAudioClient2_Impl, const OFFSET: isize>() -> ISpatialAudioClient2_Vtbl { unsafe extern "system" fn IsOffloadCapable, Impl: ISpatialAudioClient2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, category: AUDIO_STREAM_CATEGORY, isoffloadcapable: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Media/Audio/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/Audio/mod.rs index c54b278bc5..577a686884 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/Audio/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/Audio/mod.rs @@ -13,15 +13,13 @@ pub mod Endpoints; #[cfg(feature = "Win32_Media_Audio_XAudio2")] #[doc = "Required features: `\"Win32_Media_Audio_XAudio2\"`"] pub mod XAudio2; -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn ActivateAudioInterfaceAsync(deviceinterfacepath: P0, riid: *const ::windows_core::GUID, activationparams: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>, completionhandler: P1) -> ::windows_core::Result +pub unsafe fn ActivateAudioInterfaceAsync(deviceinterfacepath: P0, riid: *const ::windows_core::GUID, activationparams: ::core::option::Option<*const ::windows_core::PROPVARIANT>, completionhandler: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - ::windows_targets::link!("mmdevapi.dll" "system" fn ActivateAudioInterfaceAsync(deviceinterfacepath : ::windows_core::PCWSTR, riid : *const ::windows_core::GUID, activationparams : *const super::super::System::Com::StructuredStorage:: PROPVARIANT, completionhandler : * mut::core::ffi::c_void, activationoperation : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); + ::windows_targets::link!("mmdevapi.dll" "system" fn ActivateAudioInterfaceAsync(deviceinterfacepath : ::windows_core::PCWSTR, riid : *const ::windows_core::GUID, activationparams : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, completionhandler : * mut::core::ffi::c_void, activationoperation : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); ActivateAudioInterfaceAsync(deviceinterfacepath.into_param().abi(), riid, ::core::mem::transmute(activationparams.unwrap_or(::std::ptr::null())), completionhandler.into_param().abi(), &mut result__).from_abi(result__) } @@ -2526,9 +2524,9 @@ pub struct IDeviceTopology_Vtbl { ::windows_core::imp::com_interface!(IMMDevice, IMMDevice_Vtbl, 0xd666063f_1587_4e43_81f1_b948e807363f); ::windows_core::imp::interface_hierarchy!(IMMDevice, ::windows_core::IUnknown); impl IMMDevice { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Activate(&self, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Activate(&self, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result where T: ::windows_core::Interface, { @@ -2554,9 +2552,9 @@ impl IMMDevice { #[doc(hidden)] pub struct IMMDevice_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Activate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Activate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, dwclsctx: super::super::System::Com::CLSCTX, pactivationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Activate: usize, #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub OpenPropertyStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, stgmaccess: super::super::System::Com::STGM, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2568,9 +2566,7 @@ pub struct IMMDevice_Vtbl { ::windows_core::imp::com_interface!(IMMDeviceActivator, IMMDeviceActivator_Vtbl, 0x3b0d0ea4_d0a9_4b0e_935b_09516746fac0); ::windows_core::imp::interface_hierarchy!(IMMDeviceActivator, ::windows_core::IUnknown); impl IMMDeviceActivator { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Activate(&self, iid: *const ::windows_core::GUID, pdevice: P0, pactivationparams: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> + pub unsafe fn Activate(&self, iid: *const ::windows_core::GUID, pdevice: P0, pactivationparams: ::core::option::Option<*const ::windows_core::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { @@ -2581,10 +2577,7 @@ impl IMMDeviceActivator { #[doc(hidden)] pub struct IMMDeviceActivator_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Activate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, pdevice: *mut ::core::ffi::c_void, pactivationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Activate: usize, + pub Activate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iid: *const ::windows_core::GUID, pdevice: *mut ::core::ffi::c_void, pactivationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMMDeviceCollection, IMMDeviceCollection_Vtbl, 0x0bd7a1be_7a1a_44db_8397_cc5392387b5e); ::windows_core::imp::interface_hierarchy!(IMMDeviceCollection, ::windows_core::IUnknown); @@ -2930,19 +2923,15 @@ impl ISpatialAudioClient { pub unsafe fn IsAudioObjectFormatSupported(&self, objectformat: *const WAVEFORMATEX) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsAudioObjectFormatSupported)(::windows_core::Interface::as_raw(self), objectformat).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsSpatialAudioStreamAvailable)(::windows_core::Interface::as_raw(self), streamuuid, ::core::mem::transmute(auxiliaryinfo.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn ActivateSpatialAudioStream(&self, activationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result + pub unsafe fn ActivateSpatialAudioStream(&self, activationparams: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result where T: ::windows_core::Interface, { let mut result__ = ::std::ptr::null_mut(); - (::windows_core::Interface::vtable(self).ActivateSpatialAudioStream)(::windows_core::Interface::as_raw(self), activationparams, &T::IID, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ActivateSpatialAudioStream)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(activationparams), &T::IID, &mut result__).from_abi(result__) } } #[repr(C)] @@ -2955,14 +2944,8 @@ pub struct ISpatialAudioClient_Vtbl { pub GetSupportedAudioObjectFormatEnumerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetMaxFrameCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectformat: *const WAVEFORMATEX, framecountperbuffer: *mut u32) -> ::windows_core::HRESULT, pub IsAudioObjectFormatSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectformat: *const WAVEFORMATEX) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub IsSpatialAudioStreamAvailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - IsSpatialAudioStreamAvailable: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub ActivateSpatialAudioStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, activationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - ActivateSpatialAudioStream: usize, + pub IsSpatialAudioStreamAvailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub ActivateSpatialAudioStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, activationparams: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, riid: *const ::windows_core::GUID, stream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ISpatialAudioClient2, ISpatialAudioClient2_Vtbl, 0xcaabe452_a66a_4bee_a93e_e320463f6a53); ::windows_core::imp::interface_hierarchy!(ISpatialAudioClient2, ::windows_core::IUnknown, ISpatialAudioClient); @@ -2989,19 +2972,15 @@ impl ISpatialAudioClient2 { pub unsafe fn IsAudioObjectFormatSupported(&self, objectformat: *const WAVEFORMATEX) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.IsAudioObjectFormatSupported)(::windows_core::Interface::as_raw(self), objectformat).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn IsSpatialAudioStreamAvailable(&self, streamuuid: *const ::windows_core::GUID, auxiliaryinfo: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.IsSpatialAudioStreamAvailable)(::windows_core::Interface::as_raw(self), streamuuid, ::core::mem::transmute(auxiliaryinfo.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn ActivateSpatialAudioStream(&self, activationparams: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result + pub unsafe fn ActivateSpatialAudioStream(&self, activationparams: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result where T: ::windows_core::Interface, { let mut result__ = ::std::ptr::null_mut(); - (::windows_core::Interface::vtable(self).base__.ActivateSpatialAudioStream)(::windows_core::Interface::as_raw(self), activationparams, &T::IID, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.ActivateSpatialAudioStream)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(activationparams), &T::IID, &mut result__).from_abi(result__) } pub unsafe fn IsOffloadCapable(&self, category: AUDIO_STREAM_CATEGORY) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7332,8 +7311,6 @@ impl ::core::default::Default for SpatialAudioObjectRenderStreamActivationParams } } #[repr(C, packed(1))] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct SpatialAudioObjectRenderStreamForMetadataActivationParams { pub ObjectFormat: *const WAVEFORMATEX, pub StaticObjectTypeMask: AudioObjectType, @@ -7343,22 +7320,18 @@ pub struct SpatialAudioObjectRenderStreamForMetadataActivationParams { pub EventHandle: super::super::Foundation::HANDLE, pub MetadataFormatId: ::windows_core::GUID, pub MaxMetadataItemCount: u16, - pub MetadataActivationParams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, + pub MetadataActivationParams: *const ::windows_core::PROPVARIANT, pub NotifyObject: ::std::mem::ManuallyDrop<::core::option::Option>, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SpatialAudioObjectRenderStreamForMetadataActivationParams { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for SpatialAudioObjectRenderStreamForMetadataActivationParams { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(1))] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct SpatialAudioObjectRenderStreamForMetadataActivationParams2 { pub ObjectFormat: *const WAVEFORMATEX, pub StaticObjectTypeMask: AudioObjectType, @@ -7368,15 +7341,13 @@ pub struct SpatialAudioObjectRenderStreamForMetadataActivationParams2 { pub EventHandle: super::super::Foundation::HANDLE, pub MetadataFormatId: ::windows_core::GUID, pub MaxMetadataItemCount: u32, - pub MetadataActivationParams: *const super::super::System::Com::StructuredStorage::PROPVARIANT, + pub MetadataActivationParams: *const ::windows_core::PROPVARIANT, pub NotifyObject: ::std::mem::ManuallyDrop<::core::option::Option>, pub Options: SPATIAL_AUDIO_STREAM_OPTIONS, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SpatialAudioObjectRenderStreamForMetadataActivationParams2 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for SpatialAudioObjectRenderStreamForMetadataActivationParams2 { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/impl.rs index 5b1c3a77a7..14d4e59203 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/impl.rs @@ -200,21 +200,21 @@ impl IMDSPDevice2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_Audio\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_Audio\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] pub trait IMDSPDevice3_Impl: Sized + IMDSPDevice2_Impl { - fn GetProperty(&self, pwszpropname: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn SetProperty(&self, pwszpropname: &::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, pwszpropname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetProperty(&self, pwszpropname: &::windows_core::PCWSTR, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetFormatCapability(&self, format: WMDM_FORMATCODE) -> ::windows_core::Result; fn DeviceIoControl(&self, dwiocontrolcode: u32, lpinbuffer: *const u8, ninbuffersize: u32, lpoutbuffer: *mut u8, pnoutbuffersize: *mut u32) -> ::windows_core::Result<()>; fn FindStorage(&self, findscope: WMDM_FIND_SCOPE, pwszuniqueid: &::windows_core::PCWSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMDSPDevice3 {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] impl IMDSPDevice3_Vtbl { pub const fn new, Impl: IMDSPDevice3_Impl, const OFFSET: isize>() -> IMDSPDevice3_Vtbl { - unsafe extern "system" fn GetProperty, Impl: IMDSPDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IMDSPDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&pwszpropname)) { @@ -225,7 +225,7 @@ impl IMDSPDevice3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IMDSPDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IMDSPDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&pwszpropname), ::core::mem::transmute_copy(&pvalue)).into() @@ -1615,21 +1615,21 @@ impl IWMDMDevice2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_Audio\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_Audio\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] pub trait IWMDMDevice3_Impl: Sized + IWMDMDevice2_Impl { - fn GetProperty(&self, pwszpropname: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn SetProperty(&self, pwszpropname: &::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, pwszpropname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetProperty(&self, pwszpropname: &::windows_core::PCWSTR, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetFormatCapability(&self, format: WMDM_FORMATCODE) -> ::windows_core::Result; fn DeviceIoControl(&self, dwiocontrolcode: u32, lpinbuffer: *const u8, ninbuffersize: u32, lpoutbuffer: *mut u8, pnoutbuffersize: *mut u32) -> ::windows_core::Result<()>; fn FindStorage(&self, findscope: WMDM_FIND_SCOPE, pwszuniqueid: &::windows_core::PCWSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IWMDMDevice3 {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_Media_Audio", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Ole"))] impl IWMDMDevice3_Vtbl { pub const fn new, Impl: IWMDMDevice3_Impl, const OFFSET: isize>() -> IWMDMDevice3_Vtbl { - unsafe extern "system" fn GetProperty, Impl: IWMDMDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IWMDMDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&pwszpropname)) { @@ -1640,7 +1640,7 @@ impl IWMDMDevice3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IWMDMDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IWMDMDevice3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&pwszpropname), ::core::mem::transmute_copy(&pvalue)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/mod.rs index 13988e9c69..cee90a4162 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DeviceManager/mod.rs @@ -220,25 +220,19 @@ impl IMDSPDevice3 { pub unsafe fn GetCanonicalName(&self, pwszpnpname: &mut [u16]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetCanonicalName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pwszpnpname.as_ptr()), pwszpnpname.len().try_into().unwrap()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, pwszpropname: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, pwszpropname: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, pwszpropname: P0, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, pwszpropname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub unsafe fn GetFormatCapability(&self, format: WMDM_FORMATCODE) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFormatCapability)(::windows_core::Interface::as_raw(self), format, &mut result__).from_abi(result__) @@ -258,18 +252,9 @@ impl IMDSPDevice3 { #[doc(hidden)] pub struct IMDSPDevice3_Vtbl { pub base__: IMDSPDevice2_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetFormatCapability: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, format: WMDM_FORMATCODE, pformatsupport: *mut WMDM_FORMAT_CAPABILITY) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetFormatCapability: usize, pub DeviceIoControl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwiocontrolcode: u32, lpinbuffer: *const u8, ninbuffersize: u32, lpoutbuffer: *mut u8, pnoutbuffersize: *mut u32) -> ::windows_core::HRESULT, pub FindStorage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, findscope: WMDM_FIND_SCOPE, pwszuniqueid: ::windows_core::PCWSTR, ppstorage: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -1602,25 +1587,19 @@ impl IWMDMDevice3 { pub unsafe fn GetCanonicalName(&self, pwszpnpname: &mut [u16]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetCanonicalName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pwszpnpname.as_ptr()), pwszpnpname.len().try_into().unwrap()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, pwszpropname: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, pwszpropname: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, pwszpropname: P0, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, pwszpropname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszpropname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub unsafe fn GetFormatCapability(&self, format: WMDM_FORMATCODE) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFormatCapability)(::windows_core::Interface::as_raw(self), format, &mut result__).from_abi(result__) @@ -1640,18 +1619,9 @@ impl IWMDMDevice3 { #[doc(hidden)] pub struct IWMDMDevice3_Vtbl { pub base__: IWMDMDevice2_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszpropname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetFormatCapability: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, format: WMDM_FORMATCODE, pformatsupport: *mut WMDM_FORMAT_CAPABILITY) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetFormatCapability: usize, pub DeviceIoControl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwiocontrolcode: u32, lpinbuffer: *const u8, ninbuffersize: u32, lpoutbuffer: *mut u8, pnoutbuffersize: *mut u32) -> ::windows_core::HRESULT, pub FindStorage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, findscope: WMDM_FIND_SCOPE, pwszuniqueid: ::windows_core::PCWSTR, ppstorage: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -3647,189 +3617,158 @@ impl ::core::default::Default for WMDMRIGHTS { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct WMDM_FORMAT_CAPABILITY { pub nPropConfig: u32, pub pConfigs: *mut WMDM_PROP_CONFIG, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for WMDM_FORMAT_CAPABILITY {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_FORMAT_CAPABILITY { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for WMDM_FORMAT_CAPABILITY { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("WMDM_FORMAT_CAPABILITY").field("nPropConfig", &self.nPropConfig).field("pConfigs", &self.pConfigs).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for WMDM_FORMAT_CAPABILITY { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for WMDM_FORMAT_CAPABILITY { fn eq(&self, other: &Self) -> bool { self.nPropConfig == other.nPropConfig && self.pConfigs == other.pConfigs } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for WMDM_FORMAT_CAPABILITY {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for WMDM_FORMAT_CAPABILITY { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct WMDM_PROP_CONFIG { pub nPreference: u32, pub nPropDesc: u32, pub pPropDesc: *mut WMDM_PROP_DESC, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for WMDM_PROP_CONFIG {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_PROP_CONFIG { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for WMDM_PROP_CONFIG { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("WMDM_PROP_CONFIG").field("nPreference", &self.nPreference).field("nPropDesc", &self.nPropDesc).field("pPropDesc", &self.pPropDesc).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for WMDM_PROP_CONFIG { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for WMDM_PROP_CONFIG { fn eq(&self, other: &Self) -> bool { self.nPreference == other.nPreference && self.nPropDesc == other.nPropDesc && self.pPropDesc == other.pPropDesc } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for WMDM_PROP_CONFIG {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for WMDM_PROP_CONFIG { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct WMDM_PROP_DESC { pub pwszPropName: ::windows_core::PWSTR, pub ValidValuesForm: WMDM_ENUM_PROP_VALID_VALUES_FORM, pub ValidValues: WMDM_PROP_DESC_0, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_PROP_DESC { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for WMDM_PROP_DESC { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for WMDM_PROP_DESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub union WMDM_PROP_DESC_0 { pub ValidValuesRange: ::std::mem::ManuallyDrop, pub EnumeratedValidValues: WMDM_PROP_VALUES_ENUM, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_PROP_DESC_0 { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for WMDM_PROP_DESC_0 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for WMDM_PROP_DESC_0 { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct WMDM_PROP_VALUES_ENUM { pub cEnumValues: u32, - pub pValues: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, + pub pValues: *mut ::windows_core::PROPVARIANT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for WMDM_PROP_VALUES_ENUM {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_PROP_VALUES_ENUM { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for WMDM_PROP_VALUES_ENUM { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("WMDM_PROP_VALUES_ENUM").field("cEnumValues", &self.cEnumValues).field("pValues", &self.pValues).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for WMDM_PROP_VALUES_ENUM { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for WMDM_PROP_VALUES_ENUM { fn eq(&self, other: &Self) -> bool { self.cEnumValues == other.cEnumValues && self.pValues == other.pValues } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for WMDM_PROP_VALUES_ENUM {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for WMDM_PROP_VALUES_ENUM { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct WMDM_PROP_VALUES_RANGE { - pub rangeMin: super::super::System::Com::StructuredStorage::PROPVARIANT, - pub rangeMax: super::super::System::Com::StructuredStorage::PROPVARIANT, - pub rangeStep: super::super::System::Com::StructuredStorage::PROPVARIANT, + pub rangeMin: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, + pub rangeMax: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, + pub rangeStep: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for WMDM_PROP_VALUES_RANGE { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for WMDM_PROP_VALUES_RANGE { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("WMDM_PROP_VALUES_RANGE").field("rangeMin", &self.rangeMin).field("rangeMax", &self.rangeMax).field("rangeStep", &self.rangeStep).finish() + } +} impl ::windows_core::TypeKind for WMDM_PROP_VALUES_RANGE { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for WMDM_PROP_VALUES_RANGE { + fn eq(&self, other: &Self) -> bool { + self.rangeMin == other.rangeMin && self.rangeMax == other.rangeMax && self.rangeStep == other.rangeStep + } +} +impl ::core::cmp::Eq for WMDM_PROP_VALUES_RANGE {} impl ::core::default::Default for WMDM_PROP_VALUES_RANGE { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/impl.rs index 7d1a9cf4d1..1fad688413 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/impl.rs @@ -1,12 +1,12 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IATSCChannelTuneRequest_Impl: Sized + IChannelTuneRequest_Impl { fn MinorChannel(&self) -> ::windows_core::Result; fn SetMinorChannel(&self, minorchannel: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IATSCChannelTuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IATSCChannelTuneRequest_Vtbl { pub const fn new, Impl: IATSCChannelTuneRequest_Impl, const OFFSET: isize>() -> IATSCChannelTuneRequest_Vtbl { unsafe extern "system" fn MinorChannel, Impl: IATSCChannelTuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minorchannel: *mut i32) -> ::windows_core::HRESULT { @@ -35,15 +35,15 @@ impl IATSCChannelTuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait IATSCComponentType_Impl: Sized + IMPEG2ComponentType_Impl { fn Flags(&self) -> ::windows_core::Result; fn SetFlags(&self, flags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IATSCComponentType {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl IATSCComponentType_Vtbl { pub const fn new, Impl: IATSCComponentType_Impl, const OFFSET: isize>() -> IATSCComponentType_Vtbl { unsafe extern "system" fn Flags, Impl: IATSCComponentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: *mut i32) -> ::windows_core::HRESULT { @@ -72,17 +72,17 @@ impl IATSCComponentType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IATSCLocator_Impl: Sized + IDigitalLocator_Impl { fn PhysicalChannel(&self) -> ::windows_core::Result; fn SetPhysicalChannel(&self, physicalchannel: i32) -> ::windows_core::Result<()>; fn TSID(&self) -> ::windows_core::Result; fn SetTSID(&self, tsid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IATSCLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IATSCLocator_Vtbl { pub const fn new, Impl: IATSCLocator_Impl, const OFFSET: isize>() -> IATSCLocator_Vtbl { unsafe extern "system" fn PhysicalChannel, Impl: IATSCLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, physicalchannel: *mut i32) -> ::windows_core::HRESULT { @@ -129,15 +129,15 @@ impl IATSCLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IATSCLocator2_Impl: Sized + IATSCLocator_Impl { fn ProgramNumber(&self) -> ::windows_core::Result; fn SetProgramNumber(&self, programnumber: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IATSCLocator2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IATSCLocator2_Vtbl { pub const fn new, Impl: IATSCLocator2_Impl, const OFFSET: isize>() -> IATSCLocator2_Vtbl { unsafe extern "system" fn ProgramNumber, Impl: IATSCLocator2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, programnumber: *mut i32) -> ::windows_core::HRESULT { @@ -166,8 +166,8 @@ impl IATSCLocator2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IATSCTuningSpace_Impl: Sized + IAnalogTVTuningSpace_Impl { fn MinMinorChannel(&self) -> ::windows_core::Result; fn SetMinMinorChannel(&self, newminminorchannelval: i32) -> ::windows_core::Result<()>; @@ -178,9 +178,9 @@ pub trait IATSCTuningSpace_Impl: Sized + IAnalogTVTuningSpace_Impl { fn MaxPhysicalChannel(&self) -> ::windows_core::Result; fn SetMaxPhysicalChannel(&self, newmaxphysicalchannelval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IATSCTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IATSCTuningSpace_Vtbl { pub const fn new, Impl: IATSCTuningSpace_Impl, const OFFSET: isize>() -> IATSCTuningSpace_Vtbl { unsafe extern "system" fn MinMinorChannel, Impl: IATSCTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minminorchannelval: *mut i32) -> ::windows_core::HRESULT { @@ -1083,15 +1083,15 @@ impl IATSC_VCT_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait IAnalogAudioComponentType_Impl: Sized + IComponentType_Impl { fn AnalogAudioMode(&self) -> ::windows_core::Result; fn SetAnalogAudioMode(&self, mode: super::TVAudioMode) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IAnalogAudioComponentType {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl IAnalogAudioComponentType_Vtbl { pub const fn new, Impl: IAnalogAudioComponentType_Impl, const OFFSET: isize>() -> IAnalogAudioComponentType_Vtbl { unsafe extern "system" fn AnalogAudioMode, Impl: IAnalogAudioComponentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, mode: *mut super::TVAudioMode) -> ::windows_core::HRESULT { @@ -1120,15 +1120,15 @@ impl IAnalogAudioComponentType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAnalogLocator_Impl: Sized + ILocator_Impl { fn VideoStandard(&self) -> ::windows_core::Result; fn SetVideoStandard(&self, avs: super::AnalogVideoStandard) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAnalogLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAnalogLocator_Vtbl { pub const fn new, Impl: IAnalogLocator_Impl, const OFFSET: isize>() -> IAnalogLocator_Vtbl { unsafe extern "system" fn VideoStandard, Impl: IAnalogLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, avs: *mut super::AnalogVideoStandard) -> ::windows_core::HRESULT { @@ -1157,8 +1157,8 @@ impl IAnalogLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAnalogRadioTuningSpace_Impl: Sized + ITuningSpace_Impl { fn MinFrequency(&self) -> ::windows_core::Result; fn SetMinFrequency(&self, newminfrequencyval: i32) -> ::windows_core::Result<()>; @@ -1167,9 +1167,9 @@ pub trait IAnalogRadioTuningSpace_Impl: Sized + ITuningSpace_Impl { fn Step(&self) -> ::windows_core::Result; fn SetStep(&self, newstepval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAnalogRadioTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAnalogRadioTuningSpace_Vtbl { pub const fn new, Impl: IAnalogRadioTuningSpace_Impl, const OFFSET: isize>() -> IAnalogRadioTuningSpace_Vtbl { unsafe extern "system" fn MinFrequency, Impl: IAnalogRadioTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minfrequencyval: *mut i32) -> ::windows_core::HRESULT { @@ -1234,15 +1234,15 @@ impl IAnalogRadioTuningSpace_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAnalogRadioTuningSpace2_Impl: Sized + IAnalogRadioTuningSpace_Impl { fn CountryCode(&self) -> ::windows_core::Result; fn SetCountryCode(&self, newcountrycodeval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAnalogRadioTuningSpace2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAnalogRadioTuningSpace2_Vtbl { pub const fn new, Impl: IAnalogRadioTuningSpace2_Impl, const OFFSET: isize>() -> IAnalogRadioTuningSpace2_Vtbl { unsafe extern "system" fn CountryCode, Impl: IAnalogRadioTuningSpace2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, countrycodeval: *mut i32) -> ::windows_core::HRESULT { @@ -1271,8 +1271,8 @@ impl IAnalogRadioTuningSpace2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAnalogTVTuningSpace_Impl: Sized + ITuningSpace_Impl { fn MinChannel(&self) -> ::windows_core::Result; fn SetMinChannel(&self, newminchannelval: i32) -> ::windows_core::Result<()>; @@ -1283,9 +1283,9 @@ pub trait IAnalogTVTuningSpace_Impl: Sized + ITuningSpace_Impl { fn CountryCode(&self) -> ::windows_core::Result; fn SetCountryCode(&self, newcountrycodeval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAnalogTVTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAnalogTVTuningSpace_Vtbl { pub const fn new, Impl: IAnalogTVTuningSpace_Impl, const OFFSET: isize>() -> IAnalogTVTuningSpace_Vtbl { unsafe extern "system" fn MinChannel, Impl: IAnalogTVTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minchannelval: *mut i32) -> ::windows_core::HRESULT { @@ -1686,12 +1686,12 @@ impl IAttributeSet_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAuxInTuningSpace_Impl: Sized + ITuningSpace_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAuxInTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAuxInTuningSpace_Vtbl { pub const fn new, Impl: IAuxInTuningSpace_Impl, const OFFSET: isize>() -> IAuxInTuningSpace_Vtbl { Self { base__: ITuningSpace_Vtbl::new::() } @@ -1700,15 +1700,15 @@ impl IAuxInTuningSpace_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAuxInTuningSpace2_Impl: Sized + IAuxInTuningSpace_Impl { fn CountryCode(&self) -> ::windows_core::Result; fn SetCountryCode(&self, newcountrycodeval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAuxInTuningSpace2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAuxInTuningSpace2_Vtbl { pub const fn new, Impl: IAuxInTuningSpace2_Impl, const OFFSET: isize>() -> IAuxInTuningSpace2_Vtbl { unsafe extern "system" fn CountryCode, Impl: IAuxInTuningSpace2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, countrycodeval: *mut i32) -> ::windows_core::HRESULT { @@ -2071,15 +2071,15 @@ impl ICaptionServiceDescriptor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IChannelIDTuneRequest_Impl: Sized + ITuneRequest_Impl { fn ChannelID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetChannelID(&self, channelid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IChannelIDTuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IChannelIDTuneRequest_Vtbl { pub const fn new, Impl: IChannelIDTuneRequest_Impl, const OFFSET: isize>() -> IChannelIDTuneRequest_Vtbl { unsafe extern "system" fn ChannelID, Impl: IChannelIDTuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, channelid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2108,15 +2108,15 @@ impl IChannelIDTuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IChannelTuneRequest_Impl: Sized + ITuneRequest_Impl { fn Channel(&self) -> ::windows_core::Result; fn SetChannel(&self, channel: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IChannelTuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IChannelTuneRequest_Vtbl { pub const fn new, Impl: IChannelTuneRequest_Impl, const OFFSET: isize>() -> IChannelTuneRequest_Vtbl { unsafe extern "system" fn Channel, Impl: IChannelTuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, channel: *mut i32) -> ::windows_core::HRESULT { @@ -2145,8 +2145,8 @@ impl IChannelTuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IComponent_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn SetType(&self, ct: ::core::option::Option<&IComponentType>) -> ::windows_core::Result<()>; @@ -2158,9 +2158,9 @@ pub trait IComponent_Impl: Sized + super::super::super::System::Com::IDispatch_I fn SetDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IComponent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IComponent_Vtbl { pub const fn new, Impl: IComponent_Impl, const OFFSET: isize>() -> IComponent_Vtbl { unsafe extern "system" fn Type, Impl: IComponent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ct: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2255,8 +2255,8 @@ impl IComponent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait IComponentType_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Category(&self) -> ::windows_core::Result; fn SetCategory(&self, category: super::ComponentCategory) -> ::windows_core::Result<()>; @@ -2276,9 +2276,9 @@ pub trait IComponentType_Impl: Sized + super::super::super::System::Com::IDispat fn SetMediaType(&self, mediatype: *const super::super::MediaFoundation::AM_MEDIA_TYPE) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IComponentType {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl IComponentType_Vtbl { pub const fn new, Impl: IComponentType_Impl, const OFFSET: isize>() -> IComponentType_Vtbl { unsafe extern "system" fn Category, Impl: IComponentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, category: *mut super::ComponentCategory) -> ::windows_core::HRESULT { @@ -2445,21 +2445,21 @@ impl IComponentType_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IComponentTypes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; fn EnumComponentTypes(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn put_Item(&self, index: &super::super::super::System::Variant::VARIANT, componenttype: ::core::option::Option<&IComponentType>) -> ::windows_core::Result<()>; - fn Add(&self, componenttype: ::core::option::Option<&IComponentType>) -> ::windows_core::Result; - fn Remove(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; + fn put_Item(&self, index: &::windows_core::VARIANT, componenttype: ::core::option::Option<&IComponentType>) -> ::windows_core::Result<()>; + fn Add(&self, componenttype: ::core::option::Option<&IComponentType>) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IComponentTypes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IComponentTypes_Vtbl { pub const fn new, Impl: IComponentTypes_Impl, const OFFSET: isize>() -> IComponentTypes_Vtbl { unsafe extern "system" fn Count, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -2495,7 +2495,7 @@ impl IComponentTypes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, componenttype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, componenttype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2506,12 +2506,12 @@ impl IComponentTypes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Item, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, componenttype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Item, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, componenttype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Item(::core::mem::transmute(&index), ::windows_core::from_raw_borrowed(&componenttype)).into() } - unsafe extern "system" fn Add, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, componenttype: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, componenttype: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::windows_core::from_raw_borrowed(&componenttype)) { @@ -2522,7 +2522,7 @@ impl IComponentTypes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IComponentTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -2554,21 +2554,21 @@ impl IComponentTypes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IComponents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; fn EnumComponents(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Add(&self, component: ::core::option::Option<&IComponent>) -> ::windows_core::Result; - fn Remove(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Add(&self, component: ::core::option::Option<&IComponent>) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; - fn put_Item(&self, index: &super::super::super::System::Variant::VARIANT, ppcomponent: ::core::option::Option<&IComponent>) -> ::windows_core::Result<()>; + fn put_Item(&self, index: &::windows_core::VARIANT, ppcomponent: ::core::option::Option<&IComponent>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IComponents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IComponents_Vtbl { pub const fn new, Impl: IComponents_Impl, const OFFSET: isize>() -> IComponents_Vtbl { unsafe extern "system" fn Count, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -2604,7 +2604,7 @@ impl IComponents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2615,7 +2615,7 @@ impl IComponents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::windows_core::from_raw_borrowed(&component)) { @@ -2626,7 +2626,7 @@ impl IComponents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -2642,7 +2642,7 @@ impl IComponents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Item, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Item, Impl: IComponents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Item(::core::mem::transmute(&index), ::windows_core::from_raw_borrowed(&ppcomponent)).into() @@ -2663,20 +2663,20 @@ impl IComponents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IComponentsOld_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; fn EnumComponents(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Add(&self, component: ::core::option::Option<&IComponent>) -> ::windows_core::Result; - fn Remove(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Add(&self, component: ::core::option::Option<&IComponent>) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IComponentsOld {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IComponentsOld_Vtbl { pub const fn new, Impl: IComponentsOld_Impl, const OFFSET: isize>() -> IComponentsOld_Vtbl { unsafe extern "system" fn Count, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -2712,7 +2712,7 @@ impl IComponentsOld_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2723,7 +2723,7 @@ impl IComponentsOld_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::windows_core::from_raw_borrowed(&component)) { @@ -2734,7 +2734,7 @@ impl IComponentsOld_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IComponentsOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -2994,12 +2994,12 @@ impl IDTFilterConfig_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDTFilterEvents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDTFilterEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDTFilterEvents_Vtbl { pub const fn new, Impl: IDTFilterEvents_Impl, const OFFSET: isize>() -> IDTFilterEvents_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } @@ -3025,12 +3025,12 @@ impl IDTFilterLicenseRenewal_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBCLocator_Impl: Sized + IDigitalLocator_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBCLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBCLocator_Vtbl { pub const fn new, Impl: IDVBCLocator_Impl, const OFFSET: isize>() -> IDVBCLocator_Vtbl { Self { base__: IDigitalLocator_Vtbl::new::() } @@ -3039,8 +3039,8 @@ impl IDVBCLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBSLocator_Impl: Sized + IDigitalLocator_Impl { fn SignalPolarisation(&self) -> ::windows_core::Result; fn SetSignalPolarisation(&self, polarisationval: super::Polarisation) -> ::windows_core::Result<()>; @@ -3053,9 +3053,9 @@ pub trait IDVBSLocator_Impl: Sized + IDigitalLocator_Impl { fn Elevation(&self) -> ::windows_core::Result; fn SetElevation(&self, elevation: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBSLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBSLocator_Vtbl { pub const fn new, Impl: IDVBSLocator_Impl, const OFFSET: isize>() -> IDVBSLocator_Vtbl { unsafe extern "system" fn SignalPolarisation, Impl: IDVBSLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, polarisationval: *mut super::Polarisation) -> ::windows_core::HRESULT { @@ -3156,8 +3156,8 @@ impl IDVBSLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBSLocator2_Impl: Sized + IDVBSLocator_Impl { fn DiseqLNBSource(&self) -> ::windows_core::Result; fn SetDiseqLNBSource(&self, diseqlnbsourceval: super::LNB_Source) -> ::windows_core::Result<()>; @@ -3174,9 +3174,9 @@ pub trait IDVBSLocator2_Impl: Sized + IDVBSLocator_Impl { fn SignalPilot(&self) -> ::windows_core::Result; fn SetSignalPilot(&self, pilotval: super::Pilot) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBSLocator2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBSLocator2_Vtbl { pub const fn new, Impl: IDVBSLocator2_Impl, const OFFSET: isize>() -> IDVBSLocator2_Vtbl { unsafe extern "system" fn DiseqLNBSource, Impl: IDVBSLocator2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, diseqlnbsourceval: *mut super::LNB_Source) -> ::windows_core::HRESULT { @@ -3313,8 +3313,8 @@ impl IDVBSLocator2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBSTuningSpace_Impl: Sized + IDVBTuningSpace2_Impl { fn LowOscillator(&self) -> ::windows_core::Result; fn SetLowOscillator(&self, lowoscillator: i32) -> ::windows_core::Result<()>; @@ -3327,9 +3327,9 @@ pub trait IDVBSTuningSpace_Impl: Sized + IDVBTuningSpace2_Impl { fn SpectralInversion(&self) -> ::windows_core::Result; fn SetSpectralInversion(&self, spectralinversionval: super::SpectralInversion) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBSTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBSTuningSpace_Vtbl { pub const fn new, Impl: IDVBSTuningSpace_Impl, const OFFSET: isize>() -> IDVBSTuningSpace_Vtbl { unsafe extern "system" fn LowOscillator, Impl: IDVBSTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lowoscillator: *mut i32) -> ::windows_core::HRESULT { @@ -3430,8 +3430,8 @@ impl IDVBSTuningSpace_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBTLocator_Impl: Sized + IDigitalLocator_Impl { fn Bandwidth(&self) -> ::windows_core::Result; fn SetBandwidth(&self, bandwidthval: i32) -> ::windows_core::Result<()>; @@ -3448,9 +3448,9 @@ pub trait IDVBTLocator_Impl: Sized + IDigitalLocator_Impl { fn OtherFrequencyInUse(&self) -> ::windows_core::Result; fn SetOtherFrequencyInUse(&self, otherfrequencyinuseval: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBTLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBTLocator_Vtbl { pub const fn new, Impl: IDVBTLocator_Impl, const OFFSET: isize>() -> IDVBTLocator_Vtbl { unsafe extern "system" fn Bandwidth, Impl: IDVBTLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bandwidthval: *mut i32) -> ::windows_core::HRESULT { @@ -3587,15 +3587,15 @@ impl IDVBTLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBTLocator2_Impl: Sized + IDVBTLocator_Impl { fn PhysicalLayerPipeId(&self) -> ::windows_core::Result; fn SetPhysicalLayerPipeId(&self, physicallayerpipeidval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBTLocator2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBTLocator2_Vtbl { pub const fn new, Impl: IDVBTLocator2_Impl, const OFFSET: isize>() -> IDVBTLocator2_Vtbl { unsafe extern "system" fn PhysicalLayerPipeId, Impl: IDVBTLocator2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, physicallayerpipeidval: *mut i32) -> ::windows_core::HRESULT { @@ -3624,8 +3624,8 @@ impl IDVBTLocator2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBTuneRequest_Impl: Sized + ITuneRequest_Impl { fn ONID(&self) -> ::windows_core::Result; fn SetONID(&self, onid: i32) -> ::windows_core::Result<()>; @@ -3634,9 +3634,9 @@ pub trait IDVBTuneRequest_Impl: Sized + ITuneRequest_Impl { fn SID(&self) -> ::windows_core::Result; fn SetSID(&self, sid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBTuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBTuneRequest_Vtbl { pub const fn new, Impl: IDVBTuneRequest_Impl, const OFFSET: isize>() -> IDVBTuneRequest_Vtbl { unsafe extern "system" fn ONID, Impl: IDVBTuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onid: *mut i32) -> ::windows_core::HRESULT { @@ -3701,15 +3701,15 @@ impl IDVBTuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBTuningSpace_Impl: Sized + ITuningSpace_Impl { fn SystemType(&self) -> ::windows_core::Result; fn SetSystemType(&self, systype: super::DVBSystemType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBTuningSpace_Vtbl { pub const fn new, Impl: IDVBTuningSpace_Impl, const OFFSET: isize>() -> IDVBTuningSpace_Vtbl { unsafe extern "system" fn SystemType, Impl: IDVBTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, systype: *mut super::DVBSystemType) -> ::windows_core::HRESULT { @@ -3738,15 +3738,15 @@ impl IDVBTuningSpace_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDVBTuningSpace2_Impl: Sized + IDVBTuningSpace_Impl { fn NetworkID(&self) -> ::windows_core::Result; fn SetNetworkID(&self, networkid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDVBTuningSpace2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDVBTuningSpace2_Vtbl { pub const fn new, Impl: IDVBTuningSpace2_Impl, const OFFSET: isize>() -> IDVBTuningSpace2_Vtbl { unsafe extern "system" fn NetworkID, Impl: IDVBTuningSpace2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, networkid: *mut i32) -> ::windows_core::HRESULT { @@ -5106,12 +5106,12 @@ impl IDVB_TOT_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDigitalCableLocator_Impl: Sized + IATSCLocator2_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDigitalCableLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDigitalCableLocator_Vtbl { pub const fn new, Impl: IDigitalCableLocator_Impl, const OFFSET: isize>() -> IDigitalCableLocator_Vtbl { Self { base__: IATSCLocator2_Vtbl::new::() } @@ -5120,17 +5120,17 @@ impl IDigitalCableLocator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDigitalCableTuneRequest_Impl: Sized + IATSCChannelTuneRequest_Impl { fn MajorChannel(&self) -> ::windows_core::Result; fn SetMajorChannel(&self, majorchannel: i32) -> ::windows_core::Result<()>; fn SourceID(&self) -> ::windows_core::Result; fn SetSourceID(&self, sourceid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDigitalCableTuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDigitalCableTuneRequest_Vtbl { pub const fn new, Impl: IDigitalCableTuneRequest_Impl, const OFFSET: isize>() -> IDigitalCableTuneRequest_Vtbl { unsafe extern "system" fn MajorChannel, Impl: IDigitalCableTuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pmajorchannel: *mut i32) -> ::windows_core::HRESULT { @@ -5177,8 +5177,8 @@ impl IDigitalCableTuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDigitalCableTuningSpace_Impl: Sized + IATSCTuningSpace_Impl { fn MinMajorChannel(&self) -> ::windows_core::Result; fn SetMinMajorChannel(&self, newminmajorchannelval: i32) -> ::windows_core::Result<()>; @@ -5189,9 +5189,9 @@ pub trait IDigitalCableTuningSpace_Impl: Sized + IATSCTuningSpace_Impl { fn MaxSourceID(&self) -> ::windows_core::Result; fn SetMaxSourceID(&self, newmaxsourceidval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDigitalCableTuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDigitalCableTuningSpace_Vtbl { pub const fn new, Impl: IDigitalCableTuningSpace_Impl, const OFFSET: isize>() -> IDigitalCableTuningSpace_Vtbl { unsafe extern "system" fn MinMajorChannel, Impl: IDigitalCableTuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minmajorchannelval: *mut i32) -> ::windows_core::HRESULT { @@ -5274,12 +5274,12 @@ impl IDigitalCableTuningSpace_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDigitalLocator_Impl: Sized + ILocator_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDigitalLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDigitalLocator_Vtbl { pub const fn new, Impl: IDigitalLocator_Impl, const OFFSET: isize>() -> IDigitalLocator_Vtbl { Self { base__: ILocator_Vtbl::new::() } @@ -8641,12 +8641,12 @@ impl IETFilterConfig_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IETFilterEvents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IETFilterEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IETFilterEvents_Vtbl { pub const fn new, Impl: IETFilterEvents_Impl, const OFFSET: isize>() -> IETFilterEvents_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } @@ -9004,8 +9004,8 @@ impl IEnumTuningSpaces_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEvalRat_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_BlockedRatingAttributes(&self, ensystem: EnTvRat_System, enlevel: EnTvRat_GenericLevel) -> ::windows_core::Result; fn put_BlockedRatingAttributes(&self, ensystem: EnTvRat_System, enlevel: EnTvRat_GenericLevel, lbfattrs: i32) -> ::windows_core::Result<()>; @@ -9014,9 +9014,9 @@ pub trait IEvalRat_Impl: Sized + super::super::super::System::Com::IDispatch_Imp fn MostRestrictiveRating(&self, ensystem1: EnTvRat_System, enenlevel1: EnTvRat_GenericLevel, lbfenattr1: i32, ensystem2: EnTvRat_System, enenlevel2: EnTvRat_GenericLevel, lbfenattr2: i32, pensystem: *mut EnTvRat_System, penenlevel: *mut EnTvRat_GenericLevel, plbfenattr: *mut i32) -> ::windows_core::Result<()>; fn TestRating(&self, enshowsystem: EnTvRat_System, enshowlevel: EnTvRat_GenericLevel, lbfenshowattributes: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEvalRat {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEvalRat_Vtbl { pub const fn new, Impl: IEvalRat_Impl, const OFFSET: isize>() -> IEvalRat_Vtbl { unsafe extern "system" fn get_BlockedRatingAttributes, Impl: IEvalRat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ensystem: EnTvRat_System, enlevel: EnTvRat_GenericLevel, plbfattrs: *mut i32) -> ::windows_core::HRESULT { @@ -9190,19 +9190,19 @@ impl IGpnvsCommonBase_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGuideData_Impl: Sized { fn GetServices(&self) -> ::windows_core::Result; fn GetServiceProperties(&self, ptunerequest: ::core::option::Option<&ITuneRequest>) -> ::windows_core::Result; fn GetGuideProgramIDs(&self) -> ::windows_core::Result; - fn GetProgramProperties(&self, varprogramdescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn GetProgramProperties(&self, varprogramdescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result; fn GetScheduleEntryIDs(&self) -> ::windows_core::Result; - fn GetScheduleEntryProperties(&self, varscheduleentrydescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn GetScheduleEntryProperties(&self, varscheduleentrydescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGuideData {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGuideData_Vtbl { pub const fn new, Impl: IGuideData_Impl, const OFFSET: isize>() -> IGuideData_Vtbl { unsafe extern "system" fn GetServices, Impl: IGuideData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumtunerequests: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9238,7 +9238,7 @@ impl IGuideData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProgramProperties, Impl: IGuideData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProgramProperties, Impl: IGuideData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProgramProperties(::core::mem::transmute(&varprogramdescriptionid)) { @@ -9260,7 +9260,7 @@ impl IGuideData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetScheduleEntryProperties, Impl: IGuideData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetScheduleEntryProperties, Impl: IGuideData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetScheduleEntryProperties(::core::mem::transmute(&varscheduleentrydescriptionid)) { @@ -9285,20 +9285,16 @@ impl IGuideData_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IGuideDataEvent_Impl: Sized { fn GuideDataAcquired(&self) -> ::windows_core::Result<()>; - fn ProgramChanged(&self, varprogramdescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ServiceChanged(&self, varservicedescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ScheduleEntryChanged(&self, varscheduleentrydescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ProgramDeleted(&self, varprogramdescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ServiceDeleted(&self, varservicedescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ScheduleDeleted(&self, varscheduleentrydescriptionid: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + fn ProgramChanged(&self, varprogramdescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ServiceChanged(&self, varservicedescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ScheduleEntryChanged(&self, varscheduleentrydescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ProgramDeleted(&self, varprogramdescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ServiceDeleted(&self, varservicedescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ScheduleDeleted(&self, varscheduleentrydescriptionid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; +} impl ::windows_core::RuntimeName for IGuideDataEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IGuideDataEvent_Vtbl { pub const fn new, Impl: IGuideDataEvent_Impl, const OFFSET: isize>() -> IGuideDataEvent_Vtbl { unsafe extern "system" fn GuideDataAcquired, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9306,32 +9302,32 @@ impl IGuideDataEvent_Vtbl { let this = (*this).get_impl(); this.GuideDataAcquired().into() } - unsafe extern "system" fn ProgramChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ProgramChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ProgramChanged(::core::mem::transmute(&varprogramdescriptionid)).into() } - unsafe extern "system" fn ServiceChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ServiceChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varservicedescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ServiceChanged(::core::mem::transmute(&varservicedescriptionid)).into() } - unsafe extern "system" fn ScheduleEntryChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ScheduleEntryChanged, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ScheduleEntryChanged(::core::mem::transmute(&varscheduleentrydescriptionid)).into() } - unsafe extern "system" fn ProgramDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ProgramDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ProgramDeleted(::core::mem::transmute(&varprogramdescriptionid)).into() } - unsafe extern "system" fn ServiceDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ServiceDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varservicedescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ServiceDeleted(::core::mem::transmute(&varservicedescriptionid)).into() } - unsafe extern "system" fn ScheduleDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ScheduleDeleted, Impl: IGuideDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ScheduleDeleted(::core::mem::transmute(&varscheduleentrydescriptionid)).into() @@ -9378,16 +9374,12 @@ impl IGuideDataLoader_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IGuideDataProperty_Impl: Sized { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Language(&self) -> ::windows_core::Result; - fn Value(&self) -> ::windows_core::Result; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IGuideDataProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IGuideDataProperty_Vtbl { pub const fn new, Impl: IGuideDataProperty_Impl, const OFFSET: isize>() -> IGuideDataProperty_Vtbl { unsafe extern "system" fn Name, Impl: IGuideDataProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -9412,7 +9404,7 @@ impl IGuideDataProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: IGuideDataProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IGuideDataProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -9434,12 +9426,12 @@ impl IGuideDataProperty_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IISDBSLocator_Impl: Sized + IDVBSLocator_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IISDBSLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IISDBSLocator_Vtbl { pub const fn new, Impl: IISDBSLocator_Impl, const OFFSET: isize>() -> IISDBSLocator_Vtbl { Self { base__: IDVBSLocator_Vtbl::new::() } @@ -12482,15 +12474,15 @@ impl IIsdbTerrestrialDeliverySystemDescriptor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait ILanguageComponentType_Impl: Sized + IComponentType_Impl { fn LangID(&self) -> ::windows_core::Result; fn SetLangID(&self, langid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ILanguageComponentType {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ILanguageComponentType_Vtbl { pub const fn new, Impl: ILanguageComponentType_Impl, const OFFSET: isize>() -> ILanguageComponentType_Vtbl { unsafe extern "system" fn LangID, Impl: ILanguageComponentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, langid: *mut i32) -> ::windows_core::HRESULT { @@ -12519,8 +12511,8 @@ impl ILanguageComponentType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILocator_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn CarrierFrequency(&self) -> ::windows_core::Result; fn SetCarrierFrequency(&self, frequency: i32) -> ::windows_core::Result<()>; @@ -12538,9 +12530,9 @@ pub trait ILocator_Impl: Sized + super::super::super::System::Com::IDispatch_Imp fn SetSymbolRate(&self, rate: i32) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILocator_Vtbl { pub const fn new, Impl: ILocator_Impl, const OFFSET: isize>() -> ILocator_Vtbl { unsafe extern "system" fn CarrierFrequency, Impl: ILocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, frequency: *mut i32) -> ::windows_core::HRESULT { @@ -12689,8 +12681,8 @@ impl ILocator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMPEG2Component_Impl: Sized + IComponent_Impl { fn PID(&self) -> ::windows_core::Result; fn SetPID(&self, pid: i32) -> ::windows_core::Result<()>; @@ -12699,9 +12691,9 @@ pub trait IMPEG2Component_Impl: Sized + IComponent_Impl { fn ProgramNumber(&self) -> ::windows_core::Result; fn SetProgramNumber(&self, programnumber: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMPEG2Component {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMPEG2Component_Vtbl { pub const fn new, Impl: IMPEG2Component_Impl, const OFFSET: isize>() -> IMPEG2Component_Vtbl { unsafe extern "system" fn PID, Impl: IMPEG2Component_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut i32) -> ::windows_core::HRESULT { @@ -12766,15 +12758,15 @@ impl IMPEG2Component_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] pub trait IMPEG2ComponentType_Impl: Sized + ILanguageComponentType_Impl { fn StreamType(&self) -> ::windows_core::Result; fn SetStreamType(&self, mp2streamtype: super::MPEG2StreamType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IMPEG2ComponentType {} -#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com"))] impl IMPEG2ComponentType_Vtbl { pub const fn new, Impl: IMPEG2ComponentType_Impl, const OFFSET: isize>() -> IMPEG2ComponentType_Vtbl { unsafe extern "system" fn StreamType, Impl: IMPEG2ComponentType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, mp2streamtype: *mut super::MPEG2StreamType) -> ::windows_core::HRESULT { @@ -12803,17 +12795,17 @@ impl IMPEG2ComponentType_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMPEG2TuneRequest_Impl: Sized + ITuneRequest_Impl { fn TSID(&self) -> ::windows_core::Result; fn SetTSID(&self, tsid: i32) -> ::windows_core::Result<()>; fn ProgNo(&self) -> ::windows_core::Result; fn SetProgNo(&self, progno: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMPEG2TuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMPEG2TuneRequest_Vtbl { pub const fn new, Impl: IMPEG2TuneRequest_Impl, const OFFSET: isize>() -> IMPEG2TuneRequest_Vtbl { unsafe extern "system" fn TSID, Impl: IMPEG2TuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tsid: *mut i32) -> ::windows_core::HRESULT { @@ -12860,14 +12852,14 @@ impl IMPEG2TuneRequest_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMPEG2TuneRequestFactory_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn CreateTuneRequest(&self, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMPEG2TuneRequestFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMPEG2TuneRequestFactory_Vtbl { pub const fn new, Impl: IMPEG2TuneRequestFactory_Impl, const OFFSET: isize>() -> IMPEG2TuneRequestFactory_Vtbl { unsafe extern "system" fn CreateTuneRequest, Impl: IMPEG2TuneRequestFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, tunerequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12961,15 +12953,15 @@ impl IMPEG2_TIF_CONTROL_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSEventBinder_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Bind(&self, peventobject: ::core::option::Option<&super::super::super::System::Com::IDispatch>, eventname: &::windows_core::BSTR, eventhandler: &::windows_core::BSTR) -> ::windows_core::Result; fn Unbind(&self, cancelcookie: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSEventBinder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSEventBinder_Vtbl { pub const fn new, Impl: IMSEventBinder_Impl, const OFFSET: isize>() -> IMSEventBinder_Vtbl { unsafe extern "system" fn Bind, Impl: IMSEventBinder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventobject: *mut ::core::ffi::c_void, eventname: ::std::mem::MaybeUninit<::windows_core::BSTR>, eventhandler: ::std::mem::MaybeUninit<::windows_core::BSTR>, cancelid: *mut i32) -> ::windows_core::HRESULT { @@ -12998,8 +12990,8 @@ impl IMSEventBinder_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAnalogTuner_Impl: Sized + IMSVidTuner_Impl { fn Channel(&self) -> ::windows_core::Result; fn SetChannel(&self, channel: i32) -> ::windows_core::Result<()>; @@ -13011,9 +13003,9 @@ pub trait IMSVidAnalogTuner_Impl: Sized + IMSVidTuner_Impl { fn SetSAP(&self, fsapon: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ChannelAvailable(&self, nchannel: i32, signalstrength: *mut i32, fsignalpresent: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAnalogTuner {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAnalogTuner_Vtbl { pub const fn new, Impl: IMSVidAnalogTuner_Impl, const OFFSET: isize>() -> IMSVidAnalogTuner_Vtbl { unsafe extern "system" fn Channel, Impl: IMSVidAnalogTuner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, channel: *mut i32) -> ::windows_core::HRESULT { @@ -13108,16 +13100,16 @@ impl IMSVidAnalogTuner_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAnalogTuner2_Impl: Sized + IMSVidAnalogTuner_Impl { fn TVFormats(&self) -> ::windows_core::Result; fn TunerModes(&self) -> ::windows_core::Result; fn NumAuxInputs(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAnalogTuner2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAnalogTuner2_Vtbl { pub const fn new, Impl: IMSVidAnalogTuner2_Impl, const OFFSET: isize>() -> IMSVidAnalogTuner2_Vtbl { unsafe extern "system" fn TVFormats, Impl: IMSVidAnalogTuner2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, formats: *mut i32) -> ::windows_core::HRESULT { @@ -13164,12 +13156,12 @@ impl IMSVidAnalogTuner2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAnalogTunerEvent_Impl: Sized + IMSVidTunerEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAnalogTunerEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAnalogTunerEvent_Vtbl { pub const fn new, Impl: IMSVidAnalogTunerEvent_Impl, const OFFSET: isize>() -> IMSVidAnalogTunerEvent_Vtbl { Self { base__: IMSVidTunerEvent_Vtbl::new::() } @@ -13178,17 +13170,17 @@ impl IMSVidAnalogTunerEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAudioRenderer_Impl: Sized + IMSVidOutputDevice_Impl { fn SetVolume(&self, lvol: i32) -> ::windows_core::Result<()>; fn Volume(&self) -> ::windows_core::Result; fn SetBalance(&self, lbal: i32) -> ::windows_core::Result<()>; fn Balance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAudioRenderer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAudioRenderer_Vtbl { pub const fn new, Impl: IMSVidAudioRenderer_Impl, const OFFSET: isize>() -> IMSVidAudioRenderer_Vtbl { unsafe extern "system" fn SetVolume, Impl: IMSVidAudioRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lvol: i32) -> ::windows_core::HRESULT { @@ -13235,18 +13227,18 @@ impl IMSVidAudioRenderer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidAudioRendererDevices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pdb: ::core::option::Option<&IMSVidAudioRenderer>) -> ::windows_core::Result<()>; - fn Remove(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidAudioRendererDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidAudioRendererDevices_Vtbl { pub const fn new, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>() -> IMSVidAudioRendererDevices_Vtbl { unsafe extern "system" fn Count, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -13271,7 +13263,7 @@ impl IMSVidAudioRendererDevices_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&v)) { @@ -13287,7 +13279,7 @@ impl IMSVidAudioRendererDevices_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pdb)).into() } - unsafe extern "system" fn Remove, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IMSVidAudioRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&v)).into() @@ -13305,12 +13297,12 @@ impl IMSVidAudioRendererDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAudioRendererEvent_Impl: Sized + IMSVidOutputDeviceEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAudioRendererEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAudioRendererEvent_Vtbl { pub const fn new, Impl: IMSVidAudioRendererEvent_Impl, const OFFSET: isize>() -> IMSVidAudioRendererEvent_Vtbl { Self { base__: IMSVidOutputDeviceEvent_Vtbl::new::() } @@ -13319,8 +13311,8 @@ impl IMSVidAudioRendererEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidAudioRendererEvent2_Impl: Sized + IMSVidAudioRendererEvent_Impl { fn AVDecAudioDualMono(&self) -> ::windows_core::Result<()>; fn AVAudioSampleRate(&self) -> ::windows_core::Result<()>; @@ -13331,9 +13323,9 @@ pub trait IMSVidAudioRendererEvent2_Impl: Sized + IMSVidAudioRendererEvent_Impl fn AVDecCommonInputFormat(&self) -> ::windows_core::Result<()>; fn AVDecCommonOutputFormat(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidAudioRendererEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidAudioRendererEvent2_Vtbl { pub const fn new, Impl: IMSVidAudioRendererEvent2_Impl, const OFFSET: isize>() -> IMSVidAudioRendererEvent2_Vtbl { unsafe extern "system" fn AVDecAudioDualMono, Impl: IMSVidAudioRendererEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -13392,15 +13384,15 @@ impl IMSVidAudioRendererEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidClosedCaptioning_Impl: Sized + IMSVidFeature_Impl { fn Enable(&self) -> ::windows_core::Result; fn SetEnable(&self, on: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidClosedCaptioning {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidClosedCaptioning_Vtbl { pub const fn new, Impl: IMSVidClosedCaptioning_Impl, const OFFSET: isize>() -> IMSVidClosedCaptioning_Vtbl { unsafe extern "system" fn Enable, Impl: IMSVidClosedCaptioning_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, on: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -13429,15 +13421,15 @@ impl IMSVidClosedCaptioning_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidClosedCaptioning2_Impl: Sized + IMSVidClosedCaptioning_Impl { fn Service(&self) -> ::windows_core::Result; fn SetService(&self, on: MSVidCCService) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidClosedCaptioning2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidClosedCaptioning2_Vtbl { pub const fn new, Impl: IMSVidClosedCaptioning2_Impl, const OFFSET: isize>() -> IMSVidClosedCaptioning2_Vtbl { unsafe extern "system" fn Service, Impl: IMSVidClosedCaptioning2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, on: *mut MSVidCCService) -> ::windows_core::HRESULT { @@ -13466,14 +13458,14 @@ impl IMSVidClosedCaptioning2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidClosedCaptioning3_Impl: Sized + IMSVidClosedCaptioning2_Impl { fn TeleTextFilter(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidClosedCaptioning3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidClosedCaptioning3_Vtbl { pub const fn new, Impl: IMSVidClosedCaptioning3_Impl, const OFFSET: isize>() -> IMSVidClosedCaptioning3_Vtbl { unsafe extern "system" fn TeleTextFilter, Impl: IMSVidClosedCaptioning3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkttfilter: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -13543,8 +13535,8 @@ impl IMSVidCompositionSegment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidCtl_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn AutoSize(&self) -> ::windows_core::Result; fn SetAutoSize(&self, vbool: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -13580,7 +13572,7 @@ pub trait IMSVidCtl_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn FeaturesActive(&self) -> ::windows_core::Result; fn SetFeaturesActive(&self, pval: ::core::option::Option<&IMSVidFeatures>) -> ::windows_core::Result<()>; fn State(&self) -> ::windows_core::Result; - fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Build(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn Run(&self) -> ::windows_core::Result<()>; @@ -13588,11 +13580,11 @@ pub trait IMSVidCtl_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn Decompose(&self) -> ::windows_core::Result<()>; fn DisableVideo(&self) -> ::windows_core::Result<()>; fn DisableAudio(&self) -> ::windows_core::Result<()>; - fn ViewNext(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ViewNext(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidCtl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidCtl_Vtbl { pub const fn new, Impl: IMSVidCtl_Impl, const OFFSET: isize>() -> IMSVidCtl_Vtbl { unsafe extern "system" fn AutoSize, Impl: IMSVidCtl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbool: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -13891,7 +13883,7 @@ impl IMSVidCtl_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn View, Impl: IMSVidCtl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn View, Impl: IMSVidCtl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.View(::core::mem::transmute_copy(&v)).into() @@ -13931,7 +13923,7 @@ impl IMSVidCtl_Vtbl { let this = (*this).get_impl(); this.DisableAudio().into() } - unsafe extern "system" fn ViewNext, Impl: IMSVidCtl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ViewNext, Impl: IMSVidCtl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ViewNext(::core::mem::transmute_copy(&v)).into() @@ -13987,12 +13979,12 @@ impl IMSVidCtl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidDataServices_Impl: Sized + IMSVidFeature_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidDataServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidDataServices_Vtbl { pub const fn new, Impl: IMSVidDataServices_Impl, const OFFSET: isize>() -> IMSVidDataServices_Vtbl { Self { base__: IMSVidFeature_Vtbl::new::() } @@ -14001,12 +13993,12 @@ impl IMSVidDataServices_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidDataServicesEvent_Impl: Sized + IMSVidDeviceEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidDataServicesEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidDataServicesEvent_Vtbl { pub const fn new, Impl: IMSVidDataServicesEvent_Impl, const OFFSET: isize>() -> IMSVidDataServicesEvent_Vtbl { Self { base__: IMSVidDeviceEvent_Vtbl::new::() } @@ -14015,8 +14007,8 @@ impl IMSVidDataServicesEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidDevice_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Status(&self) -> ::windows_core::Result; @@ -14028,9 +14020,9 @@ pub trait IMSVidDevice_Impl: Sized + super::super::super::System::Com::IDispatch fn _ClassID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn IsEqualDevice(&self, device: ::core::option::Option<&IMSVidDevice>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidDevice_Vtbl { pub const fn new, Impl: IMSVidDevice_Impl, const OFFSET: isize>() -> IMSVidDevice_Vtbl { unsafe extern "system" fn Name, Impl: IMSVidDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14166,14 +14158,14 @@ impl IMSVidDevice2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidDeviceEvent_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn StateChange(&self, lpd: ::core::option::Option<&IMSVidDevice>, oldstate: i32, newstate: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidDeviceEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidDeviceEvent_Vtbl { pub const fn new, Impl: IMSVidDeviceEvent_Impl, const OFFSET: isize>() -> IMSVidDeviceEvent_Vtbl { unsafe extern "system" fn StateChange, Impl: IMSVidDeviceEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpd: *mut ::core::ffi::c_void, oldstate: i32, newstate: i32) -> ::windows_core::HRESULT { @@ -14187,17 +14179,17 @@ impl IMSVidDeviceEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_Media_MediaFoundation\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidEVR_Impl: Sized + IMSVidVideoRenderer_Impl { fn Presenter(&self) -> ::windows_core::Result; fn SetPresenter(&self, pallocpresent: ::core::option::Option<&super::super::MediaFoundation::IMFVideoPresenter>) -> ::windows_core::Result<()>; fn SetSuppressEffects(&self, bsuppress: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SuppressEffects(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidEVR {} -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_Media_MediaFoundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidEVR_Vtbl { pub const fn new, Impl: IMSVidEVR_Impl, const OFFSET: isize>() -> IMSVidEVR_Vtbl { unsafe extern "system" fn Presenter, Impl: IMSVidEVR_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppallocpresent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14244,14 +14236,14 @@ impl IMSVidEVR_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidEVREvent_Impl: Sized + IMSVidOutputDeviceEvent_Impl { fn OnUserEvent(&self, leventcode: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidEVREvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidEVREvent_Vtbl { pub const fn new, Impl: IMSVidEVREvent_Impl, const OFFSET: isize>() -> IMSVidEVREvent_Vtbl { unsafe extern "system" fn OnUserEvent, Impl: IMSVidEVREvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, leventcode: i32) -> ::windows_core::HRESULT { @@ -14265,15 +14257,15 @@ impl IMSVidEVREvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidEncoder_Impl: Sized + IMSVidFeature_Impl { fn VideoEncoderInterface(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn AudioEncoderInterface(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidEncoder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidEncoder_Vtbl { pub const fn new, Impl: IMSVidEncoder_Impl, const OFFSET: isize>() -> IMSVidEncoder_Vtbl { unsafe extern "system" fn VideoEncoderInterface, Impl: IMSVidEncoder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppencint: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14308,12 +14300,12 @@ impl IMSVidEncoder_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidFeature_Impl: Sized + IMSVidDevice_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidFeature {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidFeature_Vtbl { pub const fn new, Impl: IMSVidFeature_Impl, const OFFSET: isize>() -> IMSVidFeature_Vtbl { Self { base__: IMSVidDevice_Vtbl::new::() } @@ -14322,12 +14314,12 @@ impl IMSVidFeature_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidFeatureEvent_Impl: Sized + IMSVidDeviceEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidFeatureEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidFeatureEvent_Vtbl { pub const fn new, Impl: IMSVidFeatureEvent_Impl, const OFFSET: isize>() -> IMSVidFeatureEvent_Vtbl { Self { base__: IMSVidDeviceEvent_Vtbl::new::() } @@ -14336,18 +14328,18 @@ impl IMSVidFeatureEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidFeatures_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pdb: ::core::option::Option<&IMSVidFeature>) -> ::windows_core::Result<()>; - fn Remove(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidFeatures {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidFeatures_Vtbl { pub const fn new, Impl: IMSVidFeatures_Impl, const OFFSET: isize>() -> IMSVidFeatures_Vtbl { unsafe extern "system" fn Count, Impl: IMSVidFeatures_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -14372,7 +14364,7 @@ impl IMSVidFeatures_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IMSVidFeatures_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IMSVidFeatures_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&v)) { @@ -14388,7 +14380,7 @@ impl IMSVidFeatures_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pdb)).into() } - unsafe extern "system" fn Remove, Impl: IMSVidFeatures_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IMSVidFeatures_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&v)).into() @@ -14406,15 +14398,15 @@ impl IMSVidFeatures_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidFilePlayback_Impl: Sized + IMSVidPlayback_Impl { fn FileName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFileName(&self, filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidFilePlayback {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidFilePlayback_Vtbl { pub const fn new, Impl: IMSVidFilePlayback_Impl, const OFFSET: isize>() -> IMSVidFilePlayback_Vtbl { unsafe extern "system" fn FileName, Impl: IMSVidFilePlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14443,15 +14435,15 @@ impl IMSVidFilePlayback_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidFilePlayback2_Impl: Sized + IMSVidFilePlayback_Impl { fn Set_SourceFilter(&self, filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Set__SourceFilter(&self, filename: &::windows_core::GUID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidFilePlayback2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidFilePlayback2_Vtbl { pub const fn new, Impl: IMSVidFilePlayback2_Impl, const OFFSET: isize>() -> IMSVidFilePlayback2_Vtbl { unsafe extern "system" fn Set_SourceFilter, Impl: IMSVidFilePlayback2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14474,12 +14466,12 @@ impl IMSVidFilePlayback2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidFilePlaybackEvent_Impl: Sized + IMSVidPlaybackEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidFilePlaybackEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidFilePlaybackEvent_Vtbl { pub const fn new, Impl: IMSVidFilePlaybackEvent_Impl, const OFFSET: isize>() -> IMSVidFilePlaybackEvent_Vtbl { Self { base__: IMSVidPlaybackEvent_Vtbl::new::() } @@ -14488,16 +14480,16 @@ impl IMSVidFilePlaybackEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidGenericSink_Impl: Sized + IMSVidOutputDevice_Impl { fn SetSinkFilter(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SinkStreams(&self) -> ::windows_core::Result; fn SetSinkStreams(&self, streams: MSVidSinkStreams) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidGenericSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidGenericSink_Vtbl { pub const fn new, Impl: IMSVidGenericSink_Impl, const OFFSET: isize>() -> IMSVidGenericSink_Vtbl { unsafe extern "system" fn SetSinkFilter, Impl: IMSVidGenericSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14532,15 +14524,15 @@ impl IMSVidGenericSink_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidGenericSink2_Impl: Sized + IMSVidGenericSink_Impl { fn AddFilter(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ResetFilterList(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidGenericSink2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidGenericSink2_Vtbl { pub const fn new, Impl: IMSVidGenericSink2_Impl, const OFFSET: isize>() -> IMSVidGenericSink2_Vtbl { unsafe extern "system" fn AddFilter, Impl: IMSVidGenericSink2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14926,18 +14918,18 @@ impl IMSVidGraphSegmentUserInput_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidInputDevice_Impl: Sized + IMSVidDevice_Impl { - fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidInputDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidInputDevice_Vtbl { pub const fn new, Impl: IMSVidInputDevice_Impl, const OFFSET: isize>() -> IMSVidInputDevice_Vtbl { - unsafe extern "system" fn IsViewable, Impl: IMSVidInputDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT, pfviewable: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsViewable, Impl: IMSVidInputDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfviewable: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsViewable(::core::mem::transmute_copy(&v)) { @@ -14948,7 +14940,7 @@ impl IMSVidInputDevice_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn View, Impl: IMSVidInputDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn View, Impl: IMSVidInputDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.View(::core::mem::transmute_copy(&v)).into() @@ -14963,12 +14955,12 @@ impl IMSVidInputDevice_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidInputDeviceEvent_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidInputDeviceEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidInputDeviceEvent_Vtbl { pub const fn new, Impl: IMSVidInputDeviceEvent_Impl, const OFFSET: isize>() -> IMSVidInputDeviceEvent_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } @@ -14977,18 +14969,18 @@ impl IMSVidInputDeviceEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidInputDevices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pdb: ::core::option::Option<&IMSVidInputDevice>) -> ::windows_core::Result<()>; - fn Remove(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidInputDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidInputDevices_Vtbl { pub const fn new, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>() -> IMSVidInputDevices_Vtbl { unsafe extern "system" fn Count, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -15013,7 +15005,7 @@ impl IMSVidInputDevices_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&v)) { @@ -15029,7 +15021,7 @@ impl IMSVidInputDevices_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pdb)).into() } - unsafe extern "system" fn Remove, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IMSVidInputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&v)).into() @@ -15047,12 +15039,12 @@ impl IMSVidInputDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidOutputDevice_Impl: Sized + IMSVidDevice_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidOutputDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidOutputDevice_Vtbl { pub const fn new, Impl: IMSVidOutputDevice_Impl, const OFFSET: isize>() -> IMSVidOutputDevice_Vtbl { Self { base__: IMSVidDevice_Vtbl::new::() } @@ -15061,12 +15053,12 @@ impl IMSVidOutputDevice_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidOutputDeviceEvent_Impl: Sized + IMSVidDeviceEvent_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidOutputDeviceEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidOutputDeviceEvent_Vtbl { pub const fn new, Impl: IMSVidOutputDeviceEvent_Impl, const OFFSET: isize>() -> IMSVidOutputDeviceEvent_Vtbl { Self { base__: IMSVidDeviceEvent_Vtbl::new::() } @@ -15075,18 +15067,18 @@ impl IMSVidOutputDeviceEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidOutputDevices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pdb: ::core::option::Option<&IMSVidOutputDevice>) -> ::windows_core::Result<()>; - fn Remove(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidOutputDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidOutputDevices_Vtbl { pub const fn new, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>() -> IMSVidOutputDevices_Vtbl { unsafe extern "system" fn Count, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -15111,7 +15103,7 @@ impl IMSVidOutputDevices_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&v)) { @@ -15127,7 +15119,7 @@ impl IMSVidOutputDevices_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pdb)).into() } - unsafe extern "system" fn Remove, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IMSVidOutputDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&v)).into() @@ -15145,8 +15137,8 @@ impl IMSVidOutputDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidPlayback_Impl: Sized + IMSVidInputDevice_Impl { fn EnableResetOnStop(&self) -> ::windows_core::Result; fn SetEnableResetOnStop(&self, newval: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -15163,9 +15155,9 @@ pub trait IMSVidPlayback_Impl: Sized + IMSVidInputDevice_Impl { fn PositionMode(&self) -> ::windows_core::Result; fn Length(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidPlayback {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidPlayback_Vtbl { pub const fn new, Impl: IMSVidPlayback_Impl, const OFFSET: isize>() -> IMSVidPlayback_Vtbl { unsafe extern "system" fn EnableResetOnStop, Impl: IMSVidPlayback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -15296,14 +15288,14 @@ impl IMSVidPlayback_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidPlaybackEvent_Impl: Sized + IMSVidInputDeviceEvent_Impl { fn EndOfMedia(&self, lpd: ::core::option::Option<&IMSVidPlayback>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidPlaybackEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidPlaybackEvent_Vtbl { pub const fn new, Impl: IMSVidPlaybackEvent_Impl, const OFFSET: isize>() -> IMSVidPlaybackEvent_Vtbl { unsafe extern "system" fn EndOfMedia, Impl: IMSVidPlaybackEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpd: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15317,8 +15309,8 @@ impl IMSVidPlaybackEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidRect_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Top(&self) -> ::windows_core::Result; fn SetTop(&self, topval: i32) -> ::windows_core::Result<()>; @@ -15332,9 +15324,9 @@ pub trait IMSVidRect_Impl: Sized + super::super::super::System::Com::IDispatch_I fn SetHWnd(&self, hwndval: super::super::super::Foundation::HWND) -> ::windows_core::Result<()>; fn SetRect(&self, rectval: ::core::option::Option<&IMSVidRect>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidRect {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidRect_Vtbl { pub const fn new, Impl: IMSVidRect_Impl, const OFFSET: isize>() -> IMSVidRect_Vtbl { unsafe extern "system" fn Top, Impl: IMSVidRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, topval: *mut i32) -> ::windows_core::HRESULT { @@ -15441,8 +15433,8 @@ impl IMSVidRect_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferRecordingControl_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn StartTime(&self) -> ::windows_core::Result; fn SetStartTime(&self, rtstart: i32) -> ::windows_core::Result<()>; @@ -15453,9 +15445,9 @@ pub trait IMSVidStreamBufferRecordingControl_Impl: Sized + super::super::super:: fn RecordingType(&self) -> ::windows_core::Result; fn RecordingAttribute(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferRecordingControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferRecordingControl_Vtbl { pub const fn new, Impl: IMSVidStreamBufferRecordingControl_Impl, const OFFSET: isize>() -> IMSVidStreamBufferRecordingControl_Vtbl { unsafe extern "system" fn StartTime, Impl: IMSVidStreamBufferRecordingControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rtstart: *mut i32) -> ::windows_core::HRESULT { @@ -15550,8 +15542,8 @@ impl IMSVidStreamBufferRecordingControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSink_Impl: Sized + IMSVidOutputDevice_Impl { fn get_ContentRecorder(&self, pszfilename: &::windows_core::BSTR) -> ::windows_core::Result; fn get_ReferenceRecorder(&self, pszfilename: &::windows_core::BSTR) -> ::windows_core::Result; @@ -15560,9 +15552,9 @@ pub trait IMSVidStreamBufferSink_Impl: Sized + IMSVidOutputDevice_Impl { fn NameSetLock(&self) -> ::windows_core::Result<()>; fn SBESink(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSink_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSink_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSink_Vtbl { unsafe extern "system" fn get_ContentRecorder, Impl: IMSVidStreamBufferSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, precordingiunknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15633,14 +15625,14 @@ impl IMSVidStreamBufferSink_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSink2_Impl: Sized + IMSVidStreamBufferSink_Impl { fn UnlockProfile(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSink2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSink2_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSink2_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSink2_Vtbl { unsafe extern "system" fn UnlockProfile, Impl: IMSVidStreamBufferSink2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15654,8 +15646,8 @@ impl IMSVidStreamBufferSink2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSink3_Impl: Sized + IMSVidStreamBufferSink2_Impl { fn SetMinSeek(&self) -> ::windows_core::Result; fn AudioCounter(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -15676,9 +15668,9 @@ pub trait IMSVidStreamBufferSink3_Impl: Sized + IMSVidStreamBufferSink2_Impl { fn _DataAnalysisFilter(&self) -> ::windows_core::Result<::windows_core::GUID>; fn LicenseErrorCode(&self) -> ::windows_core::Result<::windows_core::HRESULT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSink3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSink3_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSink3_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSink3_Vtbl { unsafe extern "system" fn SetMinSeek, Impl: IMSVidStreamBufferSink3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwmin: *mut i32) -> ::windows_core::HRESULT { @@ -15869,16 +15861,16 @@ impl IMSVidStreamBufferSink3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSinkEvent_Impl: Sized + IMSVidOutputDeviceEvent_Impl { fn CertificateFailure(&self) -> ::windows_core::Result<()>; fn CertificateSuccess(&self) -> ::windows_core::Result<()>; fn WriteFailure(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSinkEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSinkEvent_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSinkEvent_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSinkEvent_Vtbl { unsafe extern "system" fn CertificateFailure, Impl: IMSVidStreamBufferSinkEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15907,15 +15899,15 @@ impl IMSVidStreamBufferSinkEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSinkEvent2_Impl: Sized + IMSVidStreamBufferSinkEvent_Impl { fn EncryptionOn(&self) -> ::windows_core::Result<()>; fn EncryptionOff(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSinkEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSinkEvent2_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSinkEvent2_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSinkEvent2_Vtbl { unsafe extern "system" fn EncryptionOn, Impl: IMSVidStreamBufferSinkEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15938,14 +15930,14 @@ impl IMSVidStreamBufferSinkEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSinkEvent3_Impl: Sized + IMSVidStreamBufferSinkEvent2_Impl { fn LicenseChange(&self, dwprot: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSinkEvent3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSinkEvent3_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSinkEvent3_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSinkEvent3_Vtbl { unsafe extern "system" fn LicenseChange, Impl: IMSVidStreamBufferSinkEvent3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwprot: i32) -> ::windows_core::HRESULT { @@ -15959,14 +15951,14 @@ impl IMSVidStreamBufferSinkEvent3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSinkEvent4_Impl: Sized + IMSVidStreamBufferSinkEvent3_Impl { fn WriteFailureClear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSinkEvent4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSinkEvent4_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSinkEvent4_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSinkEvent4_Vtbl { unsafe extern "system" fn WriteFailureClear, Impl: IMSVidStreamBufferSinkEvent4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15980,8 +15972,8 @@ impl IMSVidStreamBufferSinkEvent4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSource_Impl: Sized + IMSVidFilePlayback_Impl { fn Start(&self) -> ::windows_core::Result; fn RecordingAttribute(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -15991,9 +15983,9 @@ pub trait IMSVidStreamBufferSource_Impl: Sized + IMSVidFilePlayback_Impl { fn SetUnratedDelay(&self, dwdelay: i32) -> ::windows_core::Result<()>; fn SBESource(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSource {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSource_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSource_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSource_Vtbl { unsafe extern "system" fn Start, Impl: IMSVidStreamBufferSource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lstart: *mut i32) -> ::windows_core::HRESULT { @@ -16064,8 +16056,8 @@ impl IMSVidStreamBufferSource_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSource2_Impl: Sized + IMSVidStreamBufferSource_Impl { fn put_RateEx(&self, dwrate: f64, dwframespersecond: u32) -> ::windows_core::Result<()>; fn AudioCounter(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -16073,9 +16065,9 @@ pub trait IMSVidStreamBufferSource2_Impl: Sized + IMSVidStreamBufferSource_Impl fn CCCounter(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn WSTCounter(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSource2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSource2_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSource2_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSource2_Vtbl { unsafe extern "system" fn put_RateEx, Impl: IMSVidStreamBufferSource2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwrate: f64, dwframespersecond: u32) -> ::windows_core::HRESULT { @@ -16140,8 +16132,8 @@ impl IMSVidStreamBufferSource2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSourceEvent_Impl: Sized + IMSVidFilePlaybackEvent_Impl { fn CertificateFailure(&self) -> ::windows_core::Result<()>; fn CertificateSuccess(&self) -> ::windows_core::Result<()>; @@ -16153,9 +16145,9 @@ pub trait IMSVidStreamBufferSourceEvent_Impl: Sized + IMSVidFilePlaybackEvent_Im fn ContentBecomingStale(&self) -> ::windows_core::Result<()>; fn StaleFileDeleted(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSourceEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSourceEvent_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSourceEvent_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSourceEvent_Vtbl { unsafe extern "system" fn CertificateFailure, Impl: IMSVidStreamBufferSourceEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -16220,14 +16212,14 @@ impl IMSVidStreamBufferSourceEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSourceEvent2_Impl: Sized + IMSVidStreamBufferSourceEvent_Impl { fn RateChange(&self, qwnewrate: f64, qwoldrate: f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSourceEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSourceEvent2_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSourceEvent2_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSourceEvent2_Vtbl { unsafe extern "system" fn RateChange, Impl: IMSVidStreamBufferSourceEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, qwnewrate: f64, qwoldrate: f64) -> ::windows_core::HRESULT { @@ -16241,8 +16233,8 @@ impl IMSVidStreamBufferSourceEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferSourceEvent3_Impl: Sized + IMSVidStreamBufferSourceEvent2_Impl { fn BroadcastEvent(&self, guid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn BroadcastEventEx(&self, guid: &::windows_core::BSTR, param1: u32, param2: u32, param3: u32, param4: u32) -> ::windows_core::Result<()>; @@ -16250,9 +16242,9 @@ pub trait IMSVidStreamBufferSourceEvent3_Impl: Sized + IMSVidStreamBufferSourceE fn COPPUnblocked(&self) -> ::windows_core::Result<()>; fn ContentPrimarilyAudio(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferSourceEvent3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferSourceEvent3_Vtbl { pub const fn new, Impl: IMSVidStreamBufferSourceEvent3_Impl, const OFFSET: isize>() -> IMSVidStreamBufferSourceEvent3_Vtbl { unsafe extern "system" fn BroadcastEvent, Impl: IMSVidStreamBufferSourceEvent3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -16293,8 +16285,8 @@ impl IMSVidStreamBufferSourceEvent3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidStreamBufferV2SourceEvent_Impl: Sized + IMSVidFilePlaybackEvent_Impl { fn RatingsChanged(&self) -> ::windows_core::Result<()>; fn TimeHole(&self, streamoffsetms: i32, sizems: i32) -> ::windows_core::Result<()>; @@ -16306,9 +16298,9 @@ pub trait IMSVidStreamBufferV2SourceEvent_Impl: Sized + IMSVidFilePlaybackEvent_ fn BroadcastEventEx(&self, guid: &::windows_core::BSTR, param1: u32, param2: u32, param3: u32, param4: u32) -> ::windows_core::Result<()>; fn ContentPrimarilyAudio(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidStreamBufferV2SourceEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidStreamBufferV2SourceEvent_Vtbl { pub const fn new, Impl: IMSVidStreamBufferV2SourceEvent_Impl, const OFFSET: isize>() -> IMSVidStreamBufferV2SourceEvent_Vtbl { unsafe extern "system" fn RatingsChanged, Impl: IMSVidStreamBufferV2SourceEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -16373,17 +16365,17 @@ impl IMSVidStreamBufferV2SourceEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidTuner_Impl: Sized + IMSVidVideoInputDevice_Impl { fn Tune(&self) -> ::windows_core::Result; fn SetTune(&self, ptr: ::core::option::Option<&ITuneRequest>) -> ::windows_core::Result<()>; fn TuningSpace(&self) -> ::windows_core::Result; fn SetTuningSpace(&self, plts: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidTuner {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidTuner_Vtbl { pub const fn new, Impl: IMSVidTuner_Impl, const OFFSET: isize>() -> IMSVidTuner_Vtbl { unsafe extern "system" fn Tune, Impl: IMSVidTuner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -16430,14 +16422,14 @@ impl IMSVidTuner_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidTunerEvent_Impl: Sized + IMSVidInputDeviceEvent_Impl { fn TuneChanged(&self, lpd: ::core::option::Option<&IMSVidTuner>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidTunerEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidTunerEvent_Vtbl { pub const fn new, Impl: IMSVidTunerEvent_Impl, const OFFSET: isize>() -> IMSVidTunerEvent_Vtbl { unsafe extern "system" fn TuneChanged, Impl: IMSVidTunerEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpd: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -16451,8 +16443,8 @@ impl IMSVidTunerEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidVMR9_Impl: Sized + IMSVidVideoRenderer_Impl { fn Allocator_ID(&self) -> ::windows_core::Result; fn SetAllocator(&self, allocpresent: ::core::option::Option<&::windows_core::IUnknown>, id: i32) -> ::windows_core::Result<()>; @@ -16460,9 +16452,9 @@ pub trait IMSVidVMR9_Impl: Sized + IMSVidVideoRenderer_Impl { fn SuppressEffects(&self) -> ::windows_core::Result; fn Allocator(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidVMR9 {} -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidVMR9_Vtbl { pub const fn new, Impl: IMSVidVMR9_Impl, const OFFSET: isize>() -> IMSVidVMR9_Vtbl { unsafe extern "system" fn Allocator_ID, Impl: IMSVidVMR9_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT { @@ -16733,12 +16725,12 @@ impl IMSVidVRGraphSegment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidVideoInputDevice_Impl: Sized + IMSVidInputDevice_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidVideoInputDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidVideoInputDevice_Vtbl { pub const fn new, Impl: IMSVidVideoInputDevice_Impl, const OFFSET: isize>() -> IMSVidVideoInputDevice_Vtbl { Self { base__: IMSVidInputDevice_Vtbl::new::() } @@ -16747,8 +16739,8 @@ impl IMSVidVideoInputDevice_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidVideoRenderer_Impl: Sized + IMSVidOutputDevice_Impl { fn CustomCompositorClass(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetCustomCompositorClass(&self, compositorclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -16781,9 +16773,9 @@ pub trait IMSVidVideoRenderer_Impl: Sized + IMSVidOutputDevice_Impl { fn DecimateInput(&self) -> ::windows_core::Result; fn SetDecimateInput(&self, pdeci: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidVideoRenderer {} -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidVideoRenderer_Vtbl { pub const fn new, Impl: IMSVidVideoRenderer_Impl, const OFFSET: isize>() -> IMSVidVideoRenderer_Vtbl { unsafe extern "system" fn CustomCompositorClass, Impl: IMSVidVideoRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, compositorclsid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -17076,8 +17068,8 @@ impl IMSVidVideoRenderer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_DirectDraw\"`, `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidVideoRenderer2_Impl: Sized + IMSVidVideoRenderer_Impl { fn Allocator(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn _Allocator(&self) -> ::windows_core::Result; @@ -17087,9 +17079,9 @@ pub trait IMSVidVideoRenderer2_Impl: Sized + IMSVidVideoRenderer_Impl { fn SetSuppressEffects(&self, bsuppress: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SuppressEffects(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidVideoRenderer2 {} -#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_DirectDraw", feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidVideoRenderer2_Vtbl { pub const fn new, Impl: IMSVidVideoRenderer2_Impl, const OFFSET: isize>() -> IMSVidVideoRenderer2_Vtbl { unsafe extern "system" fn Allocator, Impl: IMSVidVideoRenderer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, allocpresent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17166,18 +17158,18 @@ impl IMSVidVideoRenderer2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMSVidVideoRendererDevices_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pdb: ::core::option::Option<&IMSVidVideoRenderer>) -> ::windows_core::Result<()>; - fn Remove(&self, v: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, v: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMSVidVideoRendererDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMSVidVideoRendererDevices_Vtbl { pub const fn new, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>() -> IMSVidVideoRendererDevices_Vtbl { unsafe extern "system" fn Count, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -17202,7 +17194,7 @@ impl IMSVidVideoRendererDevices_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&v)) { @@ -17218,7 +17210,7 @@ impl IMSVidVideoRendererDevices_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pdb)).into() } - unsafe extern "system" fn Remove, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IMSVidVideoRendererDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&v)).into() @@ -17236,14 +17228,14 @@ impl IMSVidVideoRendererDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidVideoRendererEvent_Impl: Sized + IMSVidOutputDeviceEvent_Impl { fn OverlayUnavailable(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidVideoRendererEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidVideoRendererEvent_Vtbl { pub const fn new, Impl: IMSVidVideoRendererEvent_Impl, const OFFSET: isize>() -> IMSVidVideoRendererEvent_Vtbl { unsafe extern "system" fn OverlayUnavailable, Impl: IMSVidVideoRendererEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17257,14 +17249,14 @@ impl IMSVidVideoRendererEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidVideoRendererEvent2_Impl: Sized + IMSVidOutputDeviceEvent_Impl { fn OverlayUnavailable(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidVideoRendererEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidVideoRendererEvent2_Vtbl { pub const fn new, Impl: IMSVidVideoRendererEvent2_Impl, const OFFSET: isize>() -> IMSVidVideoRendererEvent2_Vtbl { unsafe extern "system" fn OverlayUnavailable, Impl: IMSVidVideoRendererEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17278,8 +17270,8 @@ impl IMSVidVideoRendererEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidWebDVD_Impl: Sized + IMSVidPlayback_Impl { fn OnDVDEvent(&self, levent: i32, lparam1: isize, lparam2: isize) -> ::windows_core::Result<()>; fn PlayTitle(&self, ltitle: i32) -> ::windows_core::Result<()>; @@ -17377,9 +17369,9 @@ pub trait IMSVidWebDVD_Impl: Sized + IMSVidPlayback_Impl { fn DVDScreenInMouseCoordinates(&self) -> ::windows_core::Result; fn SetDVDScreenInMouseCoordinates(&self, prect: ::core::option::Option<&IMSVidRect>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidWebDVD {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidWebDVD_Vtbl { pub const fn new, Impl: IMSVidWebDVD_Impl, const OFFSET: isize>() -> IMSVidWebDVD_Vtbl { unsafe extern "system" fn OnDVDEvent, Impl: IMSVidWebDVD_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, levent: i32, lparam1: isize, lparam2: isize) -> ::windows_core::HRESULT { @@ -18266,15 +18258,15 @@ impl IMSVidWebDVD_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidWebDVD2_Impl: Sized + IMSVidWebDVD_Impl { fn get_Bookmark(&self, ppdata: *mut *mut u8, pdatalength: *mut u32) -> ::windows_core::Result<()>; fn put_Bookmark(&self, pdata: *const u8, dwdatalength: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidWebDVD2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidWebDVD2_Vtbl { pub const fn new, Impl: IMSVidWebDVD2_Impl, const OFFSET: isize>() -> IMSVidWebDVD2_Vtbl { unsafe extern "system" fn get_Bookmark, Impl: IMSVidWebDVD2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdata: *mut *mut u8, pdatalength: *mut u32) -> ::windows_core::HRESULT { @@ -18297,8 +18289,8 @@ impl IMSVidWebDVD2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidWebDVDAdm_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn ChangePassword(&self, strusername: &::windows_core::BSTR, strold: &::windows_core::BSTR, strnew: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SaveParentalLevel(&self, level: i32, strusername: &::windows_core::BSTR, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -18315,9 +18307,9 @@ pub trait IMSVidWebDVDAdm_Impl: Sized + super::super::super::System::Com::IDispa fn BookmarkOnStop(&self) -> ::windows_core::Result; fn SetBookmarkOnStop(&self, newval: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidWebDVDAdm {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidWebDVDAdm_Vtbl { pub const fn new, Impl: IMSVidWebDVDAdm_Impl, const OFFSET: isize>() -> IMSVidWebDVDAdm_Vtbl { unsafe extern "system" fn ChangePassword, Impl: IMSVidWebDVDAdm_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, strold: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnew: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -18454,10 +18446,10 @@ impl IMSVidWebDVDAdm_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidWebDVDEvent_Impl: Sized + IMSVidPlaybackEvent_Impl { - fn DVDNotify(&self, leventcode: i32, lparam1: &super::super::super::System::Variant::VARIANT, lparam2: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DVDNotify(&self, leventcode: i32, lparam1: &::windows_core::VARIANT, lparam2: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn PlayForwards(&self, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn PlayBackwards(&self, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ShowMenu(&self, menuid: DVDMenuIDConstants, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -18481,12 +18473,12 @@ pub trait IMSVidWebDVDEvent_Impl: Sized + IMSVidPlaybackEvent_Impl { fn ChangeKaraokePresMode(&self, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ChangeVideoPresMode(&self, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidWebDVDEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidWebDVDEvent_Vtbl { pub const fn new, Impl: IMSVidWebDVDEvent_Impl, const OFFSET: isize>() -> IMSVidWebDVDEvent_Vtbl { - unsafe extern "system" fn DVDNotify, Impl: IMSVidWebDVDEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, leventcode: i32, lparam1: super::super::super::System::Variant::VARIANT, lparam2: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DVDNotify, Impl: IMSVidWebDVDEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, leventcode: i32, lparam1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lparam2: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DVDNotify(::core::mem::transmute_copy(&leventcode), ::core::mem::transmute(&lparam1), ::core::mem::transmute(&lparam2)).into() @@ -18632,14 +18624,14 @@ impl IMSVidWebDVDEvent_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidXDS_Impl: Sized + IMSVidFeature_Impl { fn ChannelChangeInterface(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidXDS {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidXDS_Vtbl { pub const fn new, Impl: IMSVidXDS_Impl, const OFFSET: isize>() -> IMSVidXDS_Vtbl { unsafe extern "system" fn ChannelChangeInterface, Impl: IMSVidXDS_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkcc: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -18659,14 +18651,14 @@ impl IMSVidXDS_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSVidXDSEvent_Impl: Sized + IMSVidFeatureEvent_Impl { fn RatingChange(&self, prevratingsystem: EnTvRat_System, prevlevel: EnTvRat_GenericLevel, prevattributes: BfEnTvRat_GenericAttributes, newratingsystem: EnTvRat_System, newlevel: EnTvRat_GenericLevel, newattributes: BfEnTvRat_GenericAttributes) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSVidXDSEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSVidXDSEvent_Vtbl { pub const fn new, Impl: IMSVidXDSEvent_Impl, const OFFSET: isize>() -> IMSVidXDSEvent_Vtbl { unsafe extern "system" fn RatingChange, Impl: IMSVidXDSEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, prevratingsystem: EnTvRat_System, prevlevel: EnTvRat_GenericLevel, prevattributes: BfEnTvRat_GenericAttributes, newratingsystem: EnTvRat_System, newlevel: EnTvRat_GenericLevel, newattributes: BfEnTvRat_GenericAttributes) -> ::windows_core::HRESULT { @@ -19553,16 +19545,16 @@ impl IPTFilterLicenseRenewal_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPersistTuneXml_Impl: Sized + super::super::super::System::Com::IPersist_Impl { fn InitNew(&self) -> ::windows_core::Result<()>; - fn Load(&self, varvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Save(&self) -> ::windows_core::Result; + fn Load(&self, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Save(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPersistTuneXml {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPersistTuneXml_Vtbl { pub const fn new, Impl: IPersistTuneXml_Impl, const OFFSET: isize>() -> IPersistTuneXml_Vtbl { unsafe extern "system" fn InitNew, Impl: IPersistTuneXml_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -19570,12 +19562,12 @@ impl IPersistTuneXml_Vtbl { let this = (*this).get_impl(); this.InitNew().into() } - unsafe extern "system" fn Load, Impl: IPersistTuneXml_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Load, Impl: IPersistTuneXml_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Load(::core::mem::transmute(&varvalue)).into() } - unsafe extern "system" fn Save, Impl: IPersistTuneXml_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarfragment: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Save, Impl: IPersistTuneXml_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarfragment: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Save() { @@ -19597,17 +19589,13 @@ impl IPersistTuneXml_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IPersistTuneXmlUtility_Impl: Sized { - fn Deserialize(&self, varvalue: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::IUnknown>; + fn Deserialize(&self, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPersistTuneXmlUtility {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IPersistTuneXmlUtility_Vtbl { pub const fn new, Impl: IPersistTuneXmlUtility_Impl, const OFFSET: isize>() -> IPersistTuneXmlUtility_Vtbl { - unsafe extern "system" fn Deserialize, Impl: IPersistTuneXmlUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: super::super::super::System::Variant::VARIANT, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Deserialize, Impl: IPersistTuneXmlUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Deserialize(::core::mem::transmute(&varvalue)) { @@ -19624,14 +19612,14 @@ impl IPersistTuneXmlUtility_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPersistTuneXmlUtility2_Impl: Sized + IPersistTuneXmlUtility_Impl { fn Serialize(&self, pitunerequest: ::core::option::Option<&ITuneRequest>) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPersistTuneXmlUtility2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPersistTuneXmlUtility2_Vtbl { pub const fn new, Impl: IPersistTuneXmlUtility2_Impl, const OFFSET: isize>() -> IPersistTuneXmlUtility2_Vtbl { unsafe extern "system" fn Serialize, Impl: IPersistTuneXmlUtility2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pitunerequest: *mut ::core::ffi::c_void, pstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -21235,8 +21223,8 @@ impl ITSDT_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITuneRequest_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn TuningSpace(&self) -> ::windows_core::Result; fn Components(&self) -> ::windows_core::Result; @@ -21244,9 +21232,9 @@ pub trait ITuneRequest_Impl: Sized + super::super::super::System::Com::IDispatch fn Locator(&self) -> ::windows_core::Result; fn SetLocator(&self, locator: ::core::option::Option<&ILocator>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITuneRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITuneRequest_Vtbl { pub const fn new, Impl: ITuneRequest_Impl, const OFFSET: isize>() -> ITuneRequest_Vtbl { unsafe extern "system" fn TuningSpace, Impl: ITuneRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -21602,8 +21590,8 @@ impl ITunerCapEx_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITuningSpace_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn UniqueName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetUniqueName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -21625,9 +21613,9 @@ pub trait ITuningSpace_Impl: Sized + super::super::super::System::Com::IDispatch fn SetDefaultLocator(&self, locatorval: ::core::option::Option<&ILocator>) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITuningSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITuningSpace_Vtbl { pub const fn new, Impl: ITuningSpace_Impl, const OFFSET: isize>() -> ITuningSpace_Vtbl { unsafe extern "system" fn UniqueName, Impl: ITuningSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -21824,26 +21812,26 @@ impl ITuningSpace_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait ITuningSpaceContainer_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, varindex: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn put_Item(&self, varindex: &super::super::super::System::Variant::VARIANT, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result<()>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; + fn put_Item(&self, varindex: &::windows_core::VARIANT, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result<()>; fn TuningSpacesForCLSID(&self, spaceclsid: &::windows_core::BSTR) -> ::windows_core::Result; fn _TuningSpacesForCLSID2(&self, spaceclsid: *const ::windows_core::GUID) -> ::windows_core::Result; fn TuningSpacesForName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn FindID(&self, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result; - fn Add(&self, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result; + fn Add(&self, tuningspace: ::core::option::Option<&ITuningSpace>) -> ::windows_core::Result<::windows_core::VARIANT>; fn EnumTuningSpaces(&self) -> ::windows_core::Result; - fn Remove(&self, index: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MaxCount(&self) -> ::windows_core::Result; fn SetMaxCount(&self, maxcount: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for ITuningSpaceContainer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ITuningSpaceContainer_Vtbl { pub const fn new, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>() -> ITuningSpaceContainer_Vtbl { unsafe extern "system" fn Count, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -21868,7 +21856,7 @@ impl ITuningSpaceContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -21879,7 +21867,7 @@ impl ITuningSpaceContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Item, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Item, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Item(::core::mem::transmute(&varindex), ::windows_core::from_raw_borrowed(&tuningspace)).into() @@ -21928,7 +21916,7 @@ impl ITuningSpaceContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::windows_core::from_raw_borrowed(&tuningspace)) { @@ -21950,7 +21938,7 @@ impl ITuningSpaceContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: ITuningSpaceContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -21992,17 +21980,17 @@ impl ITuningSpaceContainer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait ITuningSpaces_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; - fn get_Item(&self, varindex: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn EnumTuningSpaces(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for ITuningSpaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ITuningSpaces_Vtbl { pub const fn new, Impl: ITuningSpaces_Impl, const OFFSET: isize>() -> ITuningSpaces_Vtbl { unsafe extern "system" fn Count, Impl: ITuningSpaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -22027,7 +22015,7 @@ impl ITuningSpaces_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ITuningSpaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ITuningSpaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -22174,12 +22162,12 @@ impl IXDSCodecConfig_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXDSCodecEvents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXDSCodecEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXDSCodecEvents_Vtbl { pub const fn new, Impl: IXDSCodecEvents_Impl, const OFFSET: isize>() -> IXDSCodecEvents_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } @@ -22188,15 +22176,15 @@ impl IXDSCodecEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IXDSToRat_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Init(&self) -> ::windows_core::Result<()>; fn ParseXDSBytePair(&self, byte1: u8, byte2: u8, pensystem: *mut EnTvRat_System, penlevel: *mut EnTvRat_GenericLevel, plbfenattributes: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IXDSToRat {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IXDSToRat_Vtbl { pub const fn new, Impl: IXDSToRat_Impl, const OFFSET: isize>() -> IXDSToRat_Vtbl { unsafe extern "system" fn Init, Impl: IXDSToRat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -22219,12 +22207,12 @@ impl IXDSToRat_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IMSVidCtlEvents_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IMSVidCtlEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IMSVidCtlEvents_Vtbl { pub const fn new, Impl: _IMSVidCtlEvents_Impl, const OFFSET: isize>() -> _IMSVidCtlEvents_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/mod.rs index 9f1b98f930..d47ab1e94b 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/Tv/mod.rs @@ -2506,33 +2506,38 @@ impl IComponentTypes { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumComponentTypes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Item(&self, index: super::super::super::System::Variant::VARIANT, componenttype: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn put_Item(&self, index: P0, componenttype: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), componenttype.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), componenttype.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, componenttype: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, componenttype: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), componenttype.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2552,22 +2557,19 @@ pub struct IComponentTypes_Vtbl { #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, pub EnumComponentTypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnewenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, componenttype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, componenttype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, componenttype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, componenttype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] put_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, componenttype: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, componenttype: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newlist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2598,25 +2600,29 @@ impl IComponents { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumComponents)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, component: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, component: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), component.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2624,13 +2630,14 @@ impl IComponents { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Clone)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Item(&self, index: super::super::super::System::Variant::VARIANT, ppcomponent: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn put_Item(&self, index: P0, ppcomponent: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), ppcomponent.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), ppcomponent.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2644,25 +2651,22 @@ pub struct IComponents_Vtbl { #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, pub EnumComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnewenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newlist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Clone: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] put_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -2690,25 +2694,29 @@ impl IComponentsOld { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumComponents)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, component: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, component: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), component.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2728,18 +2736,15 @@ pub struct IComponentsOld_Vtbl { #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, pub EnumComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnewenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcomponent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, component: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newlist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -7590,11 +7595,12 @@ impl IGuideData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetGuideProgramIDs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProgramProperties(&self, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProgramProperties(&self, varprogramdescriptionid: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProgramProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varprogramdescriptionid), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProgramProperties)(::windows_core::Interface::as_raw(self), varprogramdescriptionid.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Ole\"`"] #[cfg(feature = "Win32_System_Ole")] @@ -7602,11 +7608,12 @@ impl IGuideData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetScheduleEntryIDs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetScheduleEntryProperties(&self, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetScheduleEntryProperties(&self, varscheduleentrydescriptionid: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetScheduleEntryProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varscheduleentrydescriptionid), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetScheduleEntryProperties)(::windows_core::Interface::as_raw(self), varscheduleentrydescriptionid.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] @@ -7622,18 +7629,12 @@ pub struct IGuideData_Vtbl { pub GetGuideProgramIDs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penumprograms: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] GetGuideProgramIDs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProgramProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProgramProperties: usize, + pub GetProgramProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub GetScheduleEntryIDs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penumscheduleentries: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] GetScheduleEntryIDs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetScheduleEntryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetScheduleEntryProperties: usize, + pub GetScheduleEntryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppenumproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IGuideDataEvent, IGuideDataEvent_Vtbl, 0xefda0c80_f395_42c3_9b3c_56b37dec7bb7); ::windows_core::imp::interface_hierarchy!(IGuideDataEvent, ::windows_core::IUnknown); @@ -7641,35 +7642,41 @@ impl IGuideDataEvent { pub unsafe fn GuideDataAcquired(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GuideDataAcquired)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ProgramChanged(&self, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ProgramChanged)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varprogramdescriptionid)).ok() + pub unsafe fn ProgramChanged(&self, varprogramdescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ProgramChanged)(::windows_core::Interface::as_raw(self), varprogramdescriptionid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceChanged(&self, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ServiceChanged)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varservicedescriptionid)).ok() + pub unsafe fn ServiceChanged(&self, varservicedescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ServiceChanged)(::windows_core::Interface::as_raw(self), varservicedescriptionid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ScheduleEntryChanged(&self, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ScheduleEntryChanged)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varscheduleentrydescriptionid)).ok() + pub unsafe fn ScheduleEntryChanged(&self, varscheduleentrydescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ScheduleEntryChanged)(::windows_core::Interface::as_raw(self), varscheduleentrydescriptionid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ProgramDeleted(&self, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ProgramDeleted)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varprogramdescriptionid)).ok() + pub unsafe fn ProgramDeleted(&self, varprogramdescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ProgramDeleted)(::windows_core::Interface::as_raw(self), varprogramdescriptionid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceDeleted(&self, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ServiceDeleted)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varservicedescriptionid)).ok() + pub unsafe fn ServiceDeleted(&self, varservicedescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ServiceDeleted)(::windows_core::Interface::as_raw(self), varservicedescriptionid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ScheduleDeleted(&self, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ScheduleDeleted)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varscheduleentrydescriptionid)).ok() + pub unsafe fn ScheduleDeleted(&self, varscheduleentrydescriptionid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ScheduleDeleted)(::windows_core::Interface::as_raw(self), varscheduleentrydescriptionid.into_param().abi()).ok() } } #[repr(C)] @@ -7677,30 +7684,12 @@ impl IGuideDataEvent { pub struct IGuideDataEvent_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GuideDataAcquired: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ProgramChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ProgramChanged: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ServiceChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ServiceChanged: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ScheduleEntryChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ScheduleEntryChanged: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ProgramDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ProgramDeleted: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ServiceDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varservicedescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ServiceDeleted: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ScheduleDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ScheduleDeleted: usize, + pub ProgramChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ServiceChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varservicedescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ScheduleEntryChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ProgramDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varprogramdescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ServiceDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varservicedescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ScheduleDeleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varscheduleentrydescriptionid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IGuideDataLoader, IGuideDataLoader_Vtbl, 0x4764ff7c_fa95_4525_af4d_d32236db9e38); ::windows_core::imp::interface_hierarchy!(IGuideDataLoader, ::windows_core::IUnknown); @@ -7733,9 +7722,7 @@ impl IGuideDataProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Language)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7746,10 +7733,7 @@ pub struct IGuideDataProperty_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Language: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, idlang: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -9960,16 +9944,12 @@ impl IMSVidAnalogTuner { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10104,16 +10084,12 @@ impl IMSVidAnalogTuner2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10326,11 +10302,14 @@ impl IMSVidAudioRendererDevices { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, v: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), v.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -10340,10 +10319,11 @@ impl IMSVidAudioRendererDevices { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pdb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() + pub unsafe fn Remove(&self, v: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), v.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -10356,18 +10336,15 @@ pub struct IMSVidAudioRendererDevices_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdb: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -11003,10 +10980,8 @@ impl IMSVidCtl { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).State)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn Build(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Build)(::windows_core::Interface::as_raw(self)).ok() @@ -11029,10 +11004,8 @@ impl IMSVidCtl { pub unsafe fn DisableAudio(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DisableAudio)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ViewNext(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ViewNext)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn ViewNext(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ViewNext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -11125,10 +11098,7 @@ pub struct IMSVidCtl_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] SetFeaturesActive: usize, pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lstate: *mut MSVidCtlStateList) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub View: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - View: usize, + pub View: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Build: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Pause: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Run: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -11136,10 +11106,7 @@ pub struct IMSVidCtl_Vtbl { pub Decompose: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DisableVideo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DisableAudio: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ViewNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ViewNext: usize, + pub ViewNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -11805,11 +11772,14 @@ impl IMSVidFeatures { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, v: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), v.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -11819,10 +11789,11 @@ impl IMSVidFeatures { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pdb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() + pub unsafe fn Remove(&self, v: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), v.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -11835,18 +11806,15 @@ pub struct IMSVidFeatures_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdb: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -11902,16 +11870,12 @@ impl IMSVidFilePlayback { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12040,16 +12004,12 @@ impl IMSVidFilePlayback2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12595,16 +12555,12 @@ impl IMSVidInputDevice { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -12612,14 +12568,8 @@ impl IMSVidInputDevice { #[doc(hidden)] pub struct IMSVidInputDevice_Vtbl { pub base__: IMSVidDevice_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsViewable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT, pfviewable: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsViewable: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub View: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - View: usize, + pub IsViewable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfviewable: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub View: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -12659,11 +12609,14 @@ impl IMSVidInputDevices { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, v: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), v.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -12673,10 +12626,11 @@ impl IMSVidInputDevices { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pdb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() + pub unsafe fn Remove(&self, v: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), v.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -12689,18 +12643,15 @@ pub struct IMSVidInputDevices_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdb: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -12810,11 +12761,14 @@ impl IMSVidOutputDevices { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, v: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), v.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -12824,10 +12778,11 @@ impl IMSVidOutputDevices { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pdb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() + pub unsafe fn Remove(&self, v: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), v.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -12840,18 +12795,15 @@ pub struct IMSVidOutputDevices_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdb: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -12907,16 +12859,12 @@ impl IMSVidPlayback { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -13785,16 +13733,12 @@ impl IMSVidStreamBufferSource { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -13955,16 +13899,12 @@ impl IMSVidStreamBufferSource2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -14411,16 +14351,12 @@ impl IMSVidTuner { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -14995,16 +14931,12 @@ impl IMSVidVideoInputDevice { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -15575,11 +15507,14 @@ impl IMSVidVideoRendererDevices { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, v: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), v.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -15589,10 +15524,11 @@ impl IMSVidVideoRendererDevices { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pdb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() + pub unsafe fn Remove(&self, v: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), v.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -15605,18 +15541,15 @@ pub struct IMSVidVideoRendererDevices_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdb: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdb: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -15732,16 +15665,12 @@ impl IMSVidWebDVD { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -16347,16 +16276,12 @@ impl IMSVidWebDVD2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsEqualDevice)(::windows_core::Interface::as_raw(self), device.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsViewable(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn IsViewable(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), v, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.IsViewable)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn View(&self, v: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), v).ok() + pub unsafe fn View(&self, v: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.View)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(v)).ok() } pub unsafe fn EnableResetOnStop(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -16929,10 +16854,12 @@ impl IMSVidWebDVDEvent { { (::windows_core::Interface::vtable(self).base__.EndOfMedia)(::windows_core::Interface::as_raw(self), lpd.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DVDNotify(&self, leventcode: i32, lparam1: super::super::super::System::Variant::VARIANT, lparam2: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DVDNotify)(::windows_core::Interface::as_raw(self), leventcode, ::core::mem::transmute(lparam1), ::core::mem::transmute(lparam2)).ok() + pub unsafe fn DVDNotify(&self, leventcode: i32, lparam1: P0, lparam2: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DVDNotify)(::windows_core::Interface::as_raw(self), leventcode, lparam1.into_param().abi(), lparam2.into_param().abi()).ok() } pub unsafe fn PlayForwards(&self, benabled: P0) -> ::windows_core::Result<()> where @@ -17072,10 +16999,7 @@ impl IMSVidWebDVDEvent { #[doc(hidden)] pub struct IMSVidWebDVDEvent_Vtbl { pub base__: IMSVidPlaybackEvent_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DVDNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, leventcode: i32, lparam1: super::super::super::System::Variant::VARIANT, lparam2: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DVDNotify: usize, + pub DVDNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, leventcode: i32, lparam1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lparam2: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PlayForwards: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub PlayBackwards: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub ShowMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, menuid: DVDMenuIDConstants, benabled: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -17678,14 +17602,13 @@ impl IPersistTuneXml { pub unsafe fn InitNew(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).InitNew)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Load(&self, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Load)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() + pub unsafe fn Load(&self, varvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Load)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self) -> ::windows_core::Result { + pub unsafe fn Save(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -17696,42 +17619,35 @@ impl IPersistTuneXml { pub struct IPersistTuneXml_Vtbl { pub base__: super::super::super::System::Com::IPersist_Vtbl, pub InitNew: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Load: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarfragment: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Save: usize, + pub Load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarfragment: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPersistTuneXmlUtility, IPersistTuneXmlUtility_Vtbl, 0x990237ae_ac11_4614_be8f_dd217a4cb4cb); ::windows_core::imp::interface_hierarchy!(IPersistTuneXmlUtility, ::windows_core::IUnknown); impl IPersistTuneXmlUtility { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deserialize(&self, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::IUnknown> { + pub unsafe fn Deserialize(&self, varvalue: P0) -> ::windows_core::Result<::windows_core::IUnknown> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Deserialize)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Deserialize)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] #[doc(hidden)] pub struct IPersistTuneXmlUtility_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Deserialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: super::super::super::System::Variant::VARIANT, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Deserialize: usize, + pub Deserialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPersistTuneXmlUtility2, IPersistTuneXmlUtility2_Vtbl, 0x992e165f_ea24_4b2f_9a1d_009d92120451); ::windows_core::imp::interface_hierarchy!(IPersistTuneXmlUtility2, ::windows_core::IUnknown, IPersistTuneXmlUtility); impl IPersistTuneXmlUtility2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deserialize(&self, varvalue: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::IUnknown> { + pub unsafe fn Deserialize(&self, varvalue: P0) -> ::windows_core::Result<::windows_core::IUnknown> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Deserialize)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Deserialize)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -19609,19 +19525,23 @@ impl ITuningSpaceContainer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Item(&self, varindex: super::super::super::System::Variant::VARIANT, tuningspace: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn put_Item(&self, varindex: P0, tuningspace: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), tuningspace.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).put_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), tuningspace.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -19656,9 +19576,9 @@ impl ITuningSpaceContainer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FindID)(::windows_core::Interface::as_raw(self), tuningspace.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, tuningspace: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, tuningspace: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -19669,10 +19589,11 @@ impl ITuningSpaceContainer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumTuningSpaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } pub unsafe fn MaxCount(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -19692,13 +19613,13 @@ pub struct ITuningSpaceContainer_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub put_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] put_Item: usize, #[cfg(feature = "Win32_System_Com")] pub TuningSpacesForCLSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, spaceclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, newcoll: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -19716,15 +19637,12 @@ pub struct ITuningSpaceContainer_Vtbl { pub FindID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] FindID: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, newindex: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tuningspace: *mut ::core::ffi::c_void, newindex: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, pub EnumTuningSpaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MaxCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxcount: *mut i32) -> ::windows_core::HRESULT, pub SetMaxCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, maxcount: i32) -> ::windows_core::HRESULT, } @@ -19749,11 +19667,14 @@ impl ITuningSpaces { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn EnumTuningSpaces(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -19770,9 +19691,9 @@ pub struct ITuningSpaces_Vtbl { pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] _NewEnum: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::super::System::Variant::VARIANT, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, tuningspace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub EnumTuningSpaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/impl.rs index 0d65a32b07..c1a9463d55 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/impl.rs @@ -533,8 +533,8 @@ impl IAMCertifiedOutputProtection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMChannelInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ChannelName(&self, pbstrchannelname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn ChannelDescription(&self, pbstrchanneldescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -543,9 +543,9 @@ pub trait IAMChannelInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl fn ContactPhone(&self, pbstrcontactphone: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn ContactEmail(&self, pbstrcontactemail: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMChannelInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMChannelInfo_Vtbl { pub const fn new, Impl: IAMChannelInfo_Impl, const OFFSET: isize>() -> IAMChannelInfo_Vtbl { unsafe extern "system" fn ChannelName, Impl: IAMChannelInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrchannelname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -642,16 +642,16 @@ impl IAMClockSlave_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, litem: i32) -> ::windows_core::Result<::windows_core::IUnknown>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMCollection_Vtbl { pub const fn new, Impl: IAMCollection_Impl, const OFFSET: isize>() -> IAMCollection_Vtbl { unsafe extern "system" fn Count, Impl: IAMCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1438,16 +1438,16 @@ impl IAMExtTransport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMExtendedErrorInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn HasError(&self, phaserror: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ErrorDescription(&self, pbstrerrordescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn ErrorCode(&self, perrorcode: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMExtendedErrorInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMExtendedErrorInfo_Vtbl { pub const fn new, Impl: IAMExtendedErrorInfo_Impl, const OFFSET: isize>() -> IAMExtendedErrorInfo_Vtbl { unsafe extern "system" fn HasError, Impl: IAMExtendedErrorInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phaserror: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1476,8 +1476,8 @@ impl IAMExtendedErrorInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMExtendedSeeking_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ExSeekCapabilities(&self, pexcapabilities: *mut i32) -> ::windows_core::Result<()>; fn MarkerCount(&self, pmarkercount: *mut i32) -> ::windows_core::Result<()>; @@ -1487,9 +1487,9 @@ pub trait IAMExtendedSeeking_Impl: Sized + super::super::System::Com::IDispatch_ fn SetPlaybackSpeed(&self, speed: f64) -> ::windows_core::Result<()>; fn PlaybackSpeed(&self, pspeed: *mut f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMExtendedSeeking {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMExtendedSeeking_Vtbl { pub const fn new, Impl: IAMExtendedSeeking_Impl, const OFFSET: isize>() -> IAMExtendedSeeking_Vtbl { unsafe extern "system" fn ExSeekCapabilities, Impl: IAMExtendedSeeking_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pexcapabilities: *mut i32) -> ::windows_core::HRESULT { @@ -1772,8 +1772,8 @@ impl IAMLine21Decoder_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMMediaContent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AuthorName(&self, pbstrauthorname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn Title(&self, pbstrtitle: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1789,9 +1789,9 @@ pub trait IAMMediaContent_Impl: Sized + super::super::System::Com::IDispatch_Imp fn MoreInfoBannerURL(&self, pbstrmoreinfobannerurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn MoreInfoText(&self, pbstrmoreinfotext: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMMediaContent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMMediaContent_Vtbl { pub const fn new, Impl: IAMMediaContent_Impl, const OFFSET: isize>() -> IAMMediaContent_Vtbl { unsafe extern "system" fn AuthorName, Impl: IAMMediaContent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrauthorname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1880,16 +1880,16 @@ impl IAMMediaContent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMMediaContent2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_MediaParameter(&self, entrynum: i32, bstrname: &::windows_core::BSTR, pbstrvalue: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_MediaParameterName(&self, entrynum: i32, index: i32, pbstrname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn PlaylistCount(&self, pnumberentries: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMMediaContent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMMediaContent2_Vtbl { pub const fn new, Impl: IAMMediaContent2_Impl, const OFFSET: isize>() -> IAMMediaContent2_Vtbl { unsafe extern "system" fn get_MediaParameter, Impl: IAMMediaContent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, entrynum: i32, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2266,8 +2266,8 @@ impl IAMMultiMediaStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMNetShowConfig_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn BufferingTime(&self, pbufferingtime: *mut f64) -> ::windows_core::Result<()>; fn SetBufferingTime(&self, bufferingtime: f64) -> ::windows_core::Result<()>; @@ -2292,9 +2292,9 @@ pub trait IAMNetShowConfig_Impl: Sized + super::super::System::Com::IDispatch_Im fn EnableHTTP(&self, penablehttp: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetEnableHTTP(&self, enablehttp: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMNetShowConfig {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMNetShowConfig_Vtbl { pub const fn new, Impl: IAMNetShowConfig_Impl, const OFFSET: isize>() -> IAMNetShowConfig_Vtbl { unsafe extern "system" fn BufferingTime, Impl: IAMNetShowConfig_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbufferingtime: *mut f64) -> ::windows_core::HRESULT { @@ -2437,8 +2437,8 @@ impl IAMNetShowConfig_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMNetShowExProps_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SourceProtocol(&self, psourceprotocol: *mut i32) -> ::windows_core::Result<()>; fn Bandwidth(&self, pbandwidth: *mut i32) -> ::windows_core::Result<()>; @@ -2450,9 +2450,9 @@ pub trait IAMNetShowExProps_Impl: Sized + super::super::System::Com::IDispatch_I fn CreationDate(&self, pcreationdate: *mut f64) -> ::windows_core::Result<()>; fn SourceLink(&self, pbstrsourcelink: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMNetShowExProps {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMNetShowExProps_Vtbl { pub const fn new, Impl: IAMNetShowExProps_Impl, const OFFSET: isize>() -> IAMNetShowExProps_Vtbl { unsafe extern "system" fn SourceProtocol, Impl: IAMNetShowExProps_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psourceprotocol: *mut i32) -> ::windows_core::HRESULT { @@ -2517,15 +2517,15 @@ impl IAMNetShowExProps_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMNetShowPreroll_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetPreroll(&self, fpreroll: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Preroll(&self, pfpreroll: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMNetShowPreroll {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMNetShowPreroll_Vtbl { pub const fn new, Impl: IAMNetShowPreroll_Impl, const OFFSET: isize>() -> IAMNetShowPreroll_Vtbl { unsafe extern "system" fn SetPreroll, Impl: IAMNetShowPreroll_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fpreroll: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2548,8 +2548,8 @@ impl IAMNetShowPreroll_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMNetworkStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ReceivedPackets(&self, preceivedpackets: *mut i32) -> ::windows_core::Result<()>; fn RecoveredPackets(&self, precoveredpackets: *mut i32) -> ::windows_core::Result<()>; @@ -2559,9 +2559,9 @@ pub trait IAMNetworkStatus_Impl: Sized + super::super::System::Com::IDispatch_Im fn IsBroadcast(&self, pisbroadcast: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn BufferingProgress(&self, pbufferingprogress: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMNetworkStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMNetworkStatus_Vtbl { pub const fn new, Impl: IAMNetworkStatus_Impl, const OFFSET: isize>() -> IAMNetworkStatus_Vtbl { unsafe extern "system" fn ReceivedPackets, Impl: IAMNetworkStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, preceivedpackets: *mut i32) -> ::windows_core::HRESULT { @@ -3147,8 +3147,8 @@ impl IAMResourceControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAMStats_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Count(&self) -> ::windows_core::Result; @@ -3157,9 +3157,9 @@ pub trait IAMStats_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetIndex(&self, szname: &::windows_core::BSTR, lcreate: i32) -> ::windows_core::Result; fn AddValue(&self, lindex: i32, dvalue: f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAMStats {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAMStats_Vtbl { pub const fn new, Impl: IAMStats_Impl, const OFFSET: isize>() -> IAMStats_Vtbl { unsafe extern "system" fn Reset, Impl: IAMStats_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5211,12 +5211,12 @@ impl IBDA_DeviceControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IBDA_DiagnosticProperties_Impl: Sized + super::super::System::Com::StructuredStorage::IPropertyBag_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IBDA_DiagnosticProperties {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IBDA_DiagnosticProperties_Vtbl { pub const fn new, Impl: IBDA_DiagnosticProperties_Impl, const OFFSET: isize>() -> IBDA_DiagnosticProperties_Vtbl { Self { base__: super::super::System::Com::StructuredStorage::IPropertyBag_Vtbl::new::() } @@ -7012,17 +7012,17 @@ impl IBaseVideoMixer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBasicAudio_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetVolume(&self, lvolume: i32) -> ::windows_core::Result<()>; fn Volume(&self) -> ::windows_core::Result; fn SetBalance(&self, lbalance: i32) -> ::windows_core::Result<()>; fn Balance(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBasicAudio {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBasicAudio_Vtbl { pub const fn new, Impl: IBasicAudio_Impl, const OFFSET: isize>() -> IBasicAudio_Vtbl { unsafe extern "system" fn SetVolume, Impl: IBasicAudio_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lvolume: i32) -> ::windows_core::HRESULT { @@ -7069,8 +7069,8 @@ impl IBasicAudio_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBasicVideo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AvgTimePerFrame(&self) -> ::windows_core::Result; fn BitRate(&self) -> ::windows_core::Result; @@ -7105,9 +7105,9 @@ pub trait IBasicVideo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsUsingDefaultSource(&self) -> ::windows_core::Result<()>; fn IsUsingDefaultDestination(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBasicVideo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBasicVideo_Vtbl { pub const fn new, Impl: IBasicVideo_Impl, const OFFSET: isize>() -> IBasicVideo_Vtbl { unsafe extern "system" fn AvgTimePerFrame, Impl: IBasicVideo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pavgtimeperframe: *mut f64) -> ::windows_core::HRESULT { @@ -7388,14 +7388,14 @@ impl IBasicVideo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBasicVideo2_Impl: Sized + IBasicVideo_Impl { fn GetPreferredAspectRatio(&self, plaspectx: *mut i32, plaspecty: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBasicVideo2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBasicVideo2_Vtbl { pub const fn new, Impl: IBasicVideo2_Impl, const OFFSET: isize>() -> IBasicVideo2_Vtbl { unsafe extern "system" fn GetPreferredAspectRatio, Impl: IBasicVideo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plaspectx: *mut i32, plaspecty: *mut i32) -> ::windows_core::HRESULT { @@ -10546,20 +10546,16 @@ impl IESEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEncoderAPI_Impl: Sized { fn IsSupported(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn IsAvailable(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()>; - fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()>; - fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result; - fn SetValue(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut ::windows_core::VARIANT, valuemax: *mut ::windows_core::VARIANT, steppingdelta: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()>; + fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEncoderAPI {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEncoderAPI_Vtbl { pub const fn new, Impl: IEncoderAPI_Impl, const OFFSET: isize>() -> IEncoderAPI_Vtbl { unsafe extern "system" fn IsSupported, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -10572,17 +10568,17 @@ impl IEncoderAPI_Vtbl { let this = (*this).get_impl(); this.IsAvailable(::core::mem::transmute_copy(&api)).into() } - unsafe extern "system" fn GetParameterRange, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameterRange, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, valuemax: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, steppingdelta: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetParameterRange(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&valuemin), ::core::mem::transmute_copy(&valuemax), ::core::mem::transmute_copy(&steppingdelta)).into() } - unsafe extern "system" fn GetParameterValues, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameterValues, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetParameterValues(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&values), ::core::mem::transmute_copy(&valuescount)).into() } - unsafe extern "system" fn GetDefaultValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDefaultValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDefaultValue(::core::mem::transmute_copy(&api)) { @@ -10593,7 +10589,7 @@ impl IEncoderAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&api)) { @@ -10604,7 +10600,7 @@ impl IEncoderAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IEncoderAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&value)).into() @@ -11208,8 +11204,8 @@ impl IFilterGraph3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFilterInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FindPin(&self, strpinid: &::windows_core::BSTR) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -11220,9 +11216,9 @@ pub trait IFilterInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Filename(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFilename(&self, strfilename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFilterInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFilterInfo_Vtbl { pub const fn new, Impl: IFilterInfo_Impl, const OFFSET: isize>() -> IFilterInfo_Vtbl { unsafe extern "system" fn FindPin, Impl: IFilterInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpinid: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12124,8 +12120,8 @@ impl IMPEG2StreamIdMap_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMediaControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Run(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; @@ -12137,9 +12133,9 @@ pub trait IMediaControl_Impl: Sized + super::super::System::Com::IDispatch_Impl fn RegFilterCollection(&self) -> ::windows_core::Result; fn StopWhenReady(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMediaControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMediaControl_Vtbl { pub const fn new, Impl: IMediaControl_Impl, const OFFSET: isize>() -> IMediaControl_Vtbl { unsafe extern "system" fn Run, Impl: IMediaControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12228,8 +12224,8 @@ impl IMediaControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMediaEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetEventHandle(&self) -> ::windows_core::Result; fn GetEvent(&self, leventcode: *mut i32, lparam1: *mut isize, lparam2: *mut isize, mstimeout: i32) -> ::windows_core::Result<()>; @@ -12238,9 +12234,9 @@ pub trait IMediaEvent_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RestoreDefaultHandling(&self, levcode: i32) -> ::windows_core::Result<()>; fn FreeEventParams(&self, levcode: i32, lparam1: isize, lparam2: isize) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMediaEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMediaEvent_Vtbl { pub const fn new, Impl: IMediaEvent_Impl, const OFFSET: isize>() -> IMediaEvent_Vtbl { unsafe extern "system" fn GetEventHandle, Impl: IMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hevent: *mut isize) -> ::windows_core::HRESULT { @@ -12299,16 +12295,16 @@ impl IMediaEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMediaEventEx_Impl: Sized + IMediaEvent_Impl { fn SetNotifyWindow(&self, hwnd: isize, lmsg: i32, linstancedata: isize) -> ::windows_core::Result<()>; fn SetNotifyFlags(&self, lnonotifyflags: i32) -> ::windows_core::Result<()>; fn GetNotifyFlags(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMediaEventEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMediaEventEx_Vtbl { pub const fn new, Impl: IMediaEventEx_Impl, const OFFSET: isize>() -> IMediaEventEx_Vtbl { unsafe extern "system" fn SetNotifyWindow, Impl: IMediaEventEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: isize, lmsg: i32, linstancedata: isize) -> ::windows_core::HRESULT { @@ -12564,8 +12560,8 @@ impl IMediaParams_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMediaPosition_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Duration(&self) -> ::windows_core::Result; fn SetCurrentPosition(&self, lltime: f64) -> ::windows_core::Result<()>; @@ -12579,9 +12575,9 @@ pub trait IMediaPosition_Impl: Sized + super::super::System::Com::IDispatch_Impl fn CanSeekForward(&self) -> ::windows_core::Result; fn CanSeekBackward(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMediaPosition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMediaPosition_Vtbl { pub const fn new, Impl: IMediaPosition_Impl, const OFFSET: isize>() -> IMediaPosition_Vtbl { unsafe extern "system" fn Duration, Impl: IMediaPosition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plength: *mut f64) -> ::windows_core::HRESULT { @@ -12700,17 +12696,17 @@ impl IMediaPosition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IMediaPropertyBag_Impl: Sized + super::super::System::Com::StructuredStorage::IPropertyBag_Impl { - fn EnumProperty(&self, iproperty: u32, pvarpropertyname: *mut super::super::System::Variant::VARIANT, pvarpropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn EnumProperty(&self, iproperty: u32, pvarpropertyname: *mut ::windows_core::VARIANT, pvarpropertyvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IMediaPropertyBag {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IMediaPropertyBag_Vtbl { pub const fn new, Impl: IMediaPropertyBag_Impl, const OFFSET: isize>() -> IMediaPropertyBag_Vtbl { - unsafe extern "system" fn EnumProperty, Impl: IMediaPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iproperty: u32, pvarpropertyname: *mut super::super::System::Variant::VARIANT, pvarpropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnumProperty, Impl: IMediaPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iproperty: u32, pvarpropertyname: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnumProperty(::core::mem::transmute_copy(&iproperty), ::core::mem::transmute_copy(&pvarpropertyname), ::core::mem::transmute_copy(&pvarpropertyvalue)).into() @@ -13270,15 +13266,15 @@ impl IMediaStreamFilter_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMediaTypeInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Subtype(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMediaTypeInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMediaTypeInfo_Vtbl { pub const fn new, Impl: IMediaTypeInfo_Impl, const OFFSET: isize>() -> IMediaTypeInfo_Vtbl { unsafe extern "system" fn Type, Impl: IMediaTypeInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strtype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14489,8 +14485,8 @@ impl IPinFlowControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPinInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Pin(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn ConnectedTo(&self) -> ::windows_core::Result; @@ -14506,9 +14502,9 @@ pub trait IPinInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Disconnect(&self) -> ::windows_core::Result<()>; fn Render(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPinInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPinInfo_Vtbl { pub const fn new, Impl: IPinInfo_Impl, const OFFSET: isize>() -> IPinInfo_Vtbl { unsafe extern "system" fn Pin, Impl: IPinInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14767,23 +14763,19 @@ impl IQualityControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IQueueCommand_Impl: Sized { - fn InvokeAtStreamTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()>; - fn InvokeAtPresentationTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()>; + fn InvokeAtStreamTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::windows_core::VARIANT, pvarresult: *mut ::windows_core::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()>; + fn InvokeAtPresentationTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::windows_core::VARIANT, pvarresult: *mut ::windows_core::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IQueueCommand {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IQueueCommand_Vtbl { pub const fn new, Impl: IQueueCommand_Impl, const OFFSET: isize>() -> IQueueCommand_Vtbl { - unsafe extern "system" fn InvokeAtStreamTime, Impl: IQueueCommand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeAtStreamTime, Impl: IQueueCommand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puargerr: *mut i16) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeAtStreamTime(::core::mem::transmute_copy(&pcmd), ::core::mem::transmute_copy(&time), ::core::mem::transmute_copy(&iid), ::core::mem::transmute_copy(&dispidmethod), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&cargs), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&puargerr)).into() } - unsafe extern "system" fn InvokeAtPresentationTime, Impl: IQueueCommand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeAtPresentationTime, Impl: IQueueCommand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puargerr: *mut i16) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeAtPresentationTime(::core::mem::transmute_copy(&pcmd), ::core::mem::transmute_copy(&time), ::core::mem::transmute_copy(&iid), ::core::mem::transmute_copy(&dispidmethod), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&cargs), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&puargerr)).into() @@ -14798,15 +14790,15 @@ impl IQueueCommand_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRegFilterInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Filter(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRegFilterInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRegFilterInfo_Vtbl { pub const fn new, Impl: IRegFilterInfo_Impl, const OFFSET: isize>() -> IRegFilterInfo_Vtbl { unsafe extern "system" fn Name, Impl: IRegFilterInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -17184,12 +17176,8 @@ impl IVPVBINotify_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IVideoEncoder_Impl: Sized + IEncoderAPI_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IVideoEncoder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IVideoEncoder_Vtbl { pub const fn new, Impl: IVideoEncoder_Impl, const OFFSET: isize>() -> IVideoEncoder_Vtbl { Self { base__: IEncoderAPI_Vtbl::new::() } @@ -17518,8 +17506,8 @@ impl IVideoProcAmp_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IVideoWindow_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetCaption(&self, strcaption: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Caption(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -17561,9 +17549,9 @@ pub trait IVideoWindow_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn HideCursor(&self, hidecursor: OA_BOOL) -> ::windows_core::Result<()>; fn IsCursorHidden(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IVideoWindow {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl IVideoWindow_Vtbl { pub const fn new, Impl: IVideoWindow_Impl, const OFFSET: isize>() -> IVideoWindow_Vtbl { unsafe extern "system" fn SetCaption, Impl: IVideoWindow_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strcaption: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/mod.rs index 60296eab15..f2c921388a 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/DirectShow/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/DirectShow/mod.rs @@ -3545,22 +3545,22 @@ pub struct IBDA_DeviceControl_Vtbl { ::windows_core::imp::interface_hierarchy!(IBDA_DiagnosticProperties, ::windows_core::IUnknown, super::super::System::Com::StructuredStorage::IPropertyBag); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IBDA_DiagnosticProperties { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::super::System::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -7181,32 +7181,22 @@ impl IEncoderAPI { pub unsafe fn IsAvailable(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsAvailable)(::windows_core::Interface::as_raw(self), api).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetParameterRange)(::windows_core::Interface::as_raw(self), api, valuemin, valuemax, steppingdelta).ok() + pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut ::windows_core::VARIANT, valuemax: *mut ::windows_core::VARIANT, steppingdelta: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetParameterRange)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(valuemin), ::core::mem::transmute(valuemax), ::core::mem::transmute(steppingdelta)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetParameterValues)(::windows_core::Interface::as_raw(self), api, values, valuescount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDefaultValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), api, value).ok() + pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(value)).ok() } } #[repr(C)] @@ -7215,26 +7205,11 @@ pub struct IEncoderAPI_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub IsSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT, pub IsAvailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameterRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameterRange: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameterValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameterValues: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDefaultValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub GetParameterRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, valuemax: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, steppingdelta: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetParameterValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT, + pub GetDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IEnumFilters, IEnumFilters_Vtbl, 0x56a86893_0ad4_11ce_b03a_0020af0ba770); ::windows_core::imp::interface_hierarchy!(IEnumFilters, ::windows_core::IUnknown); @@ -9132,27 +9107,25 @@ pub struct IMediaPosition_Vtbl { ::windows_core::imp::interface_hierarchy!(IMediaPropertyBag, ::windows_core::IUnknown, super::super::System::Com::StructuredStorage::IPropertyBag); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IMediaPropertyBag { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::super::System::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnumProperty(&self, iproperty: u32, pvarpropertyname: *mut super::super::System::Variant::VARIANT, pvarpropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EnumProperty)(::windows_core::Interface::as_raw(self), iproperty, pvarpropertyname, pvarpropertyvalue).ok() + pub unsafe fn EnumProperty(&self, iproperty: u32, pvarpropertyname: *mut ::windows_core::VARIANT, pvarpropertyvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).EnumProperty)(::windows_core::Interface::as_raw(self), iproperty, ::core::mem::transmute(pvarpropertyname), ::core::mem::transmute(pvarpropertyvalue)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -9160,10 +9133,7 @@ impl IMediaPropertyBag { #[doc(hidden)] pub struct IMediaPropertyBag_Vtbl { pub base__: super::super::System::Com::StructuredStorage::IPropertyBag_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnumProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iproperty: u32, pvarpropertyname: *mut super::super::System::Variant::VARIANT, pvarpropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnumProperty: usize, + pub EnumProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iproperty: u32, pvarpropertyname: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMediaSample, IMediaSample_Vtbl, 0x56a8689a_0ad4_11ce_b03a_0020af0ba770); ::windows_core::imp::interface_hierarchy!(IMediaSample, ::windows_core::IUnknown); @@ -10683,29 +10653,19 @@ pub struct IQualityControl_Vtbl { ::windows_core::imp::com_interface!(IQueueCommand, IQueueCommand_Vtbl, 0x56a868b7_0ad4_11ce_b03a_0020af0ba770); ::windows_core::imp::interface_hierarchy!(IQueueCommand, ::windows_core::IUnknown); impl IQueueCommand { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeAtStreamTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InvokeAtStreamTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pcmd), time, iid, dispidmethod, wflags, cargs, pdispparams, pvarresult, puargerr).ok() + pub unsafe fn InvokeAtStreamTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::windows_core::VARIANT, pvarresult: *mut ::windows_core::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).InvokeAtStreamTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pcmd), time, iid, dispidmethod, wflags, cargs, ::core::mem::transmute(pdispparams), ::core::mem::transmute(pvarresult), puargerr).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeAtPresentationTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InvokeAtPresentationTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pcmd), time, iid, dispidmethod, wflags, cargs, pdispparams, pvarresult, puargerr).ok() + pub unsafe fn InvokeAtPresentationTime(&self, pcmd: *mut ::core::option::Option, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::windows_core::VARIANT, pvarresult: *mut ::windows_core::VARIANT, puargerr: *mut i16) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).InvokeAtPresentationTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pcmd), time, iid, dispidmethod, wflags, cargs, ::core::mem::transmute(pdispparams), ::core::mem::transmute(pvarresult), puargerr).ok() } } #[repr(C)] #[doc(hidden)] pub struct IQueueCommand_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeAtStreamTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeAtStreamTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeAtPresentationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const super::super::System::Variant::VARIANT, pvarresult: *mut super::super::System::Variant::VARIANT, puargerr: *mut i16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeAtPresentationTime: usize, + pub InvokeAtStreamTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puargerr: *mut i16) -> ::windows_core::HRESULT, + pub InvokeAtPresentationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcmd: *mut *mut ::core::ffi::c_void, time: f64, iid: *const ::windows_core::GUID, dispidmethod: i32, wflags: i16, cargs: i32, pdispparams: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puargerr: *mut i16) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -12490,32 +12450,22 @@ impl IVideoEncoder { pub unsafe fn IsAvailable(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.IsAvailable)(::windows_core::Interface::as_raw(self), api).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetParameterRange)(::windows_core::Interface::as_raw(self), api, valuemin, valuemax, steppingdelta).ok() + pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut ::windows_core::VARIANT, valuemax: *mut ::windows_core::VARIANT, steppingdelta: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetParameterRange)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(valuemin), ::core::mem::transmute(valuemax), ::core::mem::transmute(steppingdelta)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetParameterValues)(::windows_core::Interface::as_raw(self), api, values, valuescount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetDefaultValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), api, value).ok() + pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(value)).ok() } } #[repr(C)] diff --git a/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/impl.rs index cad9fdb8d8..d9496ca7c1 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/impl.rs @@ -1,14 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsMediaLibrarySharingDevice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DeviceID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Authorization(&self) -> ::windows_core::Result; fn SetAuthorization(&self, authorization: WindowsMediaLibrarySharingDeviceAuthorizationStatus) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsMediaLibrarySharingDevice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsMediaLibrarySharingDevice_Vtbl { pub const fn new, Impl: IWindowsMediaLibrarySharingDevice_Impl, const OFFSET: isize>() -> IWindowsMediaLibrarySharingDevice_Vtbl { unsafe extern "system" fn DeviceID, Impl: IWindowsMediaLibrarySharingDevice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, deviceid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -61,16 +61,16 @@ impl IWindowsMediaLibrarySharingDevice_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsMediaLibrarySharingDeviceProperties_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn GetProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsMediaLibrarySharingDeviceProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsMediaLibrarySharingDeviceProperties_Vtbl { pub const fn new, Impl: IWindowsMediaLibrarySharingDeviceProperties_Impl, const OFFSET: isize>() -> IWindowsMediaLibrarySharingDeviceProperties_Vtbl { unsafe extern "system" fn get_Item, Impl: IWindowsMediaLibrarySharingDeviceProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, property: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -117,15 +117,15 @@ impl IWindowsMediaLibrarySharingDeviceProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsMediaLibrarySharingDeviceProperty_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Value(&self) -> ::windows_core::Result; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsMediaLibrarySharingDeviceProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsMediaLibrarySharingDeviceProperty_Vtbl { pub const fn new, Impl: IWindowsMediaLibrarySharingDeviceProperty_Impl, const OFFSET: isize>() -> IWindowsMediaLibrarySharingDeviceProperty_Vtbl { unsafe extern "system" fn Name, Impl: IWindowsMediaLibrarySharingDeviceProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -139,7 +139,7 @@ impl IWindowsMediaLibrarySharingDeviceProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: IWindowsMediaLibrarySharingDeviceProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IWindowsMediaLibrarySharingDeviceProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -160,16 +160,16 @@ impl IWindowsMediaLibrarySharingDeviceProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsMediaLibrarySharingDevices_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn GetDevice(&self, deviceid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsMediaLibrarySharingDevices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsMediaLibrarySharingDevices_Vtbl { pub const fn new, Impl: IWindowsMediaLibrarySharingDevices_Impl, const OFFSET: isize>() -> IWindowsMediaLibrarySharingDevices_Vtbl { unsafe extern "system" fn get_Item, Impl: IWindowsMediaLibrarySharingDevices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, device: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -216,8 +216,8 @@ impl IWindowsMediaLibrarySharingDevices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsMediaLibrarySharingServices_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn showShareMediaCPL(&self, device: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn userHomeMediaSharingState(&self) -> ::windows_core::Result; @@ -239,9 +239,9 @@ pub trait IWindowsMediaLibrarySharingServices_Impl: Sized + super::super::System fn getAllDevices(&self) -> ::windows_core::Result; fn customSettingsApplied(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsMediaLibrarySharingServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsMediaLibrarySharingServices_Vtbl { pub const fn new, Impl: IWindowsMediaLibrarySharingServices_Impl, const OFFSET: isize>() -> IWindowsMediaLibrarySharingServices_Vtbl { unsafe extern "system" fn showShareMediaCPL, Impl: IWindowsMediaLibrarySharingServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, device: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/mod.rs index b1bdab8371..45870907ec 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/LibrarySharingServices/mod.rs @@ -101,9 +101,7 @@ impl IWindowsMediaLibrarySharingDeviceProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -114,10 +112,7 @@ impl IWindowsMediaLibrarySharingDeviceProperty { pub struct IWindowsMediaLibrarySharingDeviceProperty_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( diff --git a/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/impl.rs index 175762caf2..f140b2e1a4 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/impl.rs @@ -114,28 +114,28 @@ impl IClusterDetector_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICodecAPI_Impl: Sized { fn IsSupported(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn IsModifiable(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()>; - fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()>; - fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result; - fn SetValue(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut ::windows_core::VARIANT, valuemax: *mut ::windows_core::VARIANT, steppingdelta: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()>; + fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RegisterForEvent(&self, api: *const ::windows_core::GUID, userdata: isize) -> ::windows_core::Result<()>; fn UnregisterForEvent(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn SetAllDefaults(&self) -> ::windows_core::Result<()>; - fn SetValueWithNotify(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()>; + fn SetValueWithNotify(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()>; fn SetAllDefaultsWithNotify(&self, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()>; fn GetAllSettings(&self, __midl__icodecapi0000: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; fn SetAllSettings(&self, __midl__icodecapi0001: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; fn SetAllSettingsWithNotify(&self, __midl__icodecapi0002: ::core::option::Option<&super::super::System::Com::IStream>, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICodecAPI {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICodecAPI_Vtbl { pub const fn new, Impl: ICodecAPI_Impl, const OFFSET: isize>() -> ICodecAPI_Vtbl { unsafe extern "system" fn IsSupported, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -148,17 +148,17 @@ impl ICodecAPI_Vtbl { let this = (*this).get_impl(); this.IsModifiable(::core::mem::transmute_copy(&api)).into() } - unsafe extern "system" fn GetParameterRange, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameterRange, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, valuemax: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, steppingdelta: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetParameterRange(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&valuemin), ::core::mem::transmute_copy(&valuemax), ::core::mem::transmute_copy(&steppingdelta)).into() } - unsafe extern "system" fn GetParameterValues, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameterValues, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetParameterValues(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&values), ::core::mem::transmute_copy(&valuescount)).into() } - unsafe extern "system" fn GetDefaultValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDefaultValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDefaultValue(::core::mem::transmute_copy(&api)) { @@ -169,7 +169,7 @@ impl ICodecAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&api)) { @@ -180,7 +180,7 @@ impl ICodecAPI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&value)).into() @@ -200,7 +200,7 @@ impl ICodecAPI_Vtbl { let this = (*this).get_impl(); this.SetAllDefaults().into() } - unsafe extern "system" fn SetValueWithNotify, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValueWithNotify, Impl: ICodecAPI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValueWithNotify(::core::mem::transmute_copy(&api), ::core::mem::transmute_copy(&value), ::core::mem::transmute_copy(&changedparam), ::core::mem::transmute_copy(&changedparamcount)).into() @@ -2604,8 +2604,6 @@ impl IMFASFContentInfo_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFASFIndexer_Impl: Sized { fn SetFlags(&self, dwflags: u32) -> ::windows_core::Result<()>; fn GetFlags(&self) -> ::windows_core::Result; @@ -2615,15 +2613,13 @@ pub trait IMFASFIndexer_Impl: Sized { fn GetIndexByteStreamCount(&self) -> ::windows_core::Result; fn GetIndexStatus(&self, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pfisindexed: *mut super::super::Foundation::BOOL, pbindexdescriptor: *mut u8, pcbindexdescriptor: *mut u32) -> ::windows_core::Result<()>; fn SetIndexStatus(&self, pbindexdescriptor: *const u8, cbindexdescriptor: u32, fgenerateindex: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn GetSeekPositionForValue(&self, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::Result<()>; + fn GetSeekPositionForValue(&self, pvarvalue: *const ::windows_core::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::Result<()>; fn GenerateIndexEntries(&self, piasfpacketsample: ::core::option::Option<&IMFSample>) -> ::windows_core::Result<()>; fn CommitIndex(&self, picontentinfo: ::core::option::Option<&IMFASFContentInfo>) -> ::windows_core::Result<()>; fn GetIndexWriteSpace(&self) -> ::windows_core::Result; fn GetCompletedIndex(&self, piindexbuffer: ::core::option::Option<&IMFMediaBuffer>, cboffsetwithinindex: u64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFASFIndexer {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFASFIndexer_Vtbl { pub const fn new, Impl: IMFASFIndexer_Impl, const OFFSET: isize>() -> IMFASFIndexer_Vtbl { unsafe extern "system" fn SetFlags, Impl: IMFASFIndexer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwflags: u32) -> ::windows_core::HRESULT { @@ -2684,7 +2680,7 @@ impl IMFASFIndexer_Vtbl { let this = (*this).get_impl(); this.SetIndexStatus(::core::mem::transmute_copy(&pbindexdescriptor), ::core::mem::transmute_copy(&cbindexdescriptor), ::core::mem::transmute_copy(&fgenerateindex)).into() } - unsafe extern "system" fn GetSeekPositionForValue, Impl: IMFASFIndexer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSeekPositionForValue, Impl: IMFASFIndexer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetSeekPositionForValue(::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&pindexidentifier), ::core::mem::transmute_copy(&pcboffsetwithindata), ::core::mem::transmute_copy(&phnsapproxtime), ::core::mem::transmute_copy(&pdwpayloadnumberofstreamwithinpacket)).into() @@ -2924,8 +2920,6 @@ impl IMFASFMutualExclusion_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFASFProfile_Impl: Sized + IMFAttributes_Impl { fn GetStreamCount(&self) -> ::windows_core::Result; fn GetStream(&self, dwstreamindex: u32, pwstreamnumber: *mut u16, ppistream: *mut ::core::option::Option) -> ::windows_core::Result<()>; @@ -2944,9 +2938,7 @@ pub trait IMFASFProfile_Impl: Sized + IMFAttributes_Impl { fn CreateStreamPrioritization(&self) -> ::windows_core::Result; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFASFProfile {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFASFProfile_Vtbl { pub const fn new, Impl: IMFASFProfile_Impl, const OFFSET: isize>() -> IMFASFProfile_Vtbl { unsafe extern "system" fn GetStreamCount, Impl: IMFASFProfile_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcstreams: *mut u32) -> ::windows_core::HRESULT { @@ -3195,8 +3187,6 @@ impl IMFASFSplitter_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFASFStreamConfig_Impl: Sized + IMFAttributes_Impl { fn GetStreamType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetStreamNumber(&self) -> u16; @@ -3209,9 +3199,7 @@ pub trait IMFASFStreamConfig_Impl: Sized + IMFAttributes_Impl { fn RemoveAllPayloadExtensions(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFASFStreamConfig {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFASFStreamConfig_Vtbl { pub const fn new, Impl: IMFASFStreamConfig_Impl, const OFFSET: isize>() -> IMFASFStreamConfig_Vtbl { unsafe extern "system" fn GetStreamType, Impl: IMFASFStreamConfig_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidstreamtype: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -3537,16 +3525,12 @@ impl IMFASFStreamSelector_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFActivate_Impl: Sized + IMFAttributes_Impl { fn ActivateObject(&self, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn ShutdownObject(&self) -> ::windows_core::Result<()>; fn DetachObject(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFActivate {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFActivate_Vtbl { pub const fn new, Impl: IMFActivate_Impl, const OFFSET: isize>() -> IMFActivate_Vtbl { unsafe extern "system" fn ActivateObject, Impl: IMFActivate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3689,12 +3673,10 @@ impl IMFAsyncResult_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFAttributes_Impl: Sized { - fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result; - fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; + fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result; fn Compare(&self, ptheirs: ::core::option::Option<&IMFAttributes>, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result; fn GetUINT32(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result; fn GetUINT64(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result; @@ -3707,7 +3689,7 @@ pub trait IMFAttributes_Impl: Sized { fn GetBlob(&self, guidkey: *const ::windows_core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows_core::Result<()>; fn GetAllocatedBlob(&self, guidkey: *const ::windows_core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows_core::Result<()>; fn GetUnknown(&self, guidkey: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn DeleteAllItems(&self) -> ::windows_core::Result<()>; fn SetUINT32(&self, guidkey: *const ::windows_core::GUID, unvalue: u32) -> ::windows_core::Result<()>; @@ -3720,15 +3702,13 @@ pub trait IMFAttributes_Impl: Sized { fn LockStore(&self) -> ::windows_core::Result<()>; fn UnlockStore(&self) -> ::windows_core::Result<()>; fn GetCount(&self) -> ::windows_core::Result; - fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn CopyAllItems(&self, pdest: ::core::option::Option<&IMFAttributes>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFAttributes {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFAttributes_Vtbl { pub const fn new, Impl: IMFAttributes_Impl, const OFFSET: isize>() -> IMFAttributes_Vtbl { - unsafe extern "system" fn GetItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetItem(::core::mem::transmute_copy(&guidkey), ::core::mem::transmute_copy(&pvalue)).into() @@ -3744,7 +3724,7 @@ impl IMFAttributes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CompareItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pbresult: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn CompareItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CompareItem(::core::mem::transmute_copy(&guidkey), ::core::mem::transmute_copy(&value)) { @@ -3857,7 +3837,7 @@ impl IMFAttributes_Vtbl { let this = (*this).get_impl(); this.GetUnknown(::core::mem::transmute_copy(&guidkey), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn SetItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetItem, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetItem(::core::mem::transmute_copy(&guidkey), ::core::mem::transmute_copy(&value)).into() @@ -3928,7 +3908,7 @@ impl IMFAttributes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetItemByIndex, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetItemByIndex, Impl: IMFAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetItemByIndex(::core::mem::transmute_copy(&unindex), ::core::mem::transmute_copy(&pguidkey), ::core::mem::transmute_copy(&pvalue)).into() @@ -3976,14 +3956,14 @@ impl IMFAttributes_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_Audio\"`"] +#[cfg(feature = "Win32_Media_Audio")] pub trait IMFAudioMediaType_Impl: Sized + IMFMediaType_Impl { fn GetAudioFormat(&self) -> *mut super::Audio::WAVEFORMATEX; } -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Media_Audio")] impl ::windows_core::RuntimeName for IMFAudioMediaType {} -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Media_Audio")] impl IMFAudioMediaType_Vtbl { pub const fn new, Impl: IMFAudioMediaType_Impl, const OFFSET: isize>() -> IMFAudioMediaType_Vtbl { unsafe extern "system" fn GetAudioFormat, Impl: IMFAudioMediaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> *mut super::Audio::WAVEFORMATEX { @@ -4609,8 +4589,6 @@ impl IMFCameraControlDefaults_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFCameraControlDefaultsCollection_Impl: Sized + IMFAttributes_Impl { fn GetControlCount(&self) -> u32; fn GetControl(&self, index: u32) -> ::windows_core::Result; @@ -4619,9 +4597,7 @@ pub trait IMFCameraControlDefaultsCollection_Impl: Sized + IMFAttributes_Impl { fn RemoveControl(&self, controlset: *const ::windows_core::GUID, constrolid: u32) -> ::windows_core::Result<()>; fn RemoveAllControls(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFCameraControlDefaultsCollection {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFCameraControlDefaultsCollection_Vtbl { pub const fn new, Impl: IMFCameraControlDefaultsCollection_Impl, const OFFSET: isize>() -> IMFCameraControlDefaultsCollection_Vtbl { unsafe extern "system" fn GetControlCount, Impl: IMFCameraControlDefaultsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> u32 { @@ -8032,20 +8008,18 @@ impl IMFMediaEngineEMENotify_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaEngineEx_Impl: Sized + IMFMediaEngine_Impl { fn SetSourceFromByteStream(&self, pbytestream: ::core::option::Option<&IMFByteStream>, purl: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetStatistics(&self, statisticid: MF_MEDIA_ENGINE_STATISTIC) -> ::windows_core::Result; + fn GetStatistics(&self, statisticid: MF_MEDIA_ENGINE_STATISTIC) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn UpdateVideoStream(&self, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows_core::Result<()>; fn GetBalance(&self) -> f64; fn SetBalance(&self, balance: f64) -> ::windows_core::Result<()>; fn IsPlaybackRateSupported(&self, rate: f64) -> super::super::Foundation::BOOL; fn FrameStep(&self, forward: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetResourceCharacteristics(&self) -> ::windows_core::Result; - fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetNumberOfStreams(&self) -> ::windows_core::Result; - fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows_core::Result; fn SetStreamSelection(&self, dwstreamindex: u32, enabled: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn ApplyStreamSelections(&self) -> ::windows_core::Result<()>; @@ -8073,9 +8047,7 @@ pub trait IMFMediaEngineEx_Impl: Sized + IMFMediaEngine_Impl { fn SetCurrentTimeEx(&self, seektime: f64, seekmode: MF_MEDIA_ENGINE_SEEK_MODE) -> ::windows_core::Result<()>; fn EnableTimeUpdateTimer(&self, fenabletimer: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaEngineEx {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaEngineEx_Vtbl { pub const fn new, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>() -> IMFMediaEngineEx_Vtbl { unsafe extern "system" fn SetSourceFromByteStream, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbytestream: *mut ::core::ffi::c_void, purl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8083,7 +8055,7 @@ impl IMFMediaEngineEx_Vtbl { let this = (*this).get_impl(); this.SetSourceFromByteStream(::windows_core::from_raw_borrowed(&pbytestream), ::core::mem::transmute(&purl)).into() } - unsafe extern "system" fn GetStatistics, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, statisticid: MF_MEDIA_ENGINE_STATISTIC, pstatistic: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStatistics, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, statisticid: MF_MEDIA_ENGINE_STATISTIC, pstatistic: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStatistics(::core::mem::transmute_copy(&statisticid)) { @@ -8130,7 +8102,7 @@ impl IMFMediaEngineEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPresentationAttribute, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPresentationAttribute, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPresentationAttribute(::core::mem::transmute_copy(&guidmfattribute)) { @@ -8152,7 +8124,7 @@ impl IMFMediaEngineEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetStreamAttribute, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStreamAttribute, Impl: IMFMediaEngineEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStreamAttribute(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&guidmfattribute)) { @@ -8810,17 +8782,13 @@ impl IMFMediaError_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaEvent_Impl: Sized + IMFAttributes_Impl { fn GetType(&self) -> ::windows_core::Result; fn GetExtendedType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetStatus(&self) -> ::windows_core::Result<::windows_core::HRESULT>; - fn GetValue(&self) -> ::windows_core::Result; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaEvent {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaEvent_Vtbl { pub const fn new, Impl: IMFMediaEvent_Impl, const OFFSET: isize>() -> IMFMediaEvent_Vtbl { unsafe extern "system" fn GetType, Impl: IMFMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pmet: *mut u32) -> ::windows_core::HRESULT { @@ -8856,7 +8824,7 @@ impl IMFMediaEvent_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IMFMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IMFMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -8879,17 +8847,13 @@ impl IMFMediaEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaEventGenerator_Impl: Sized { fn GetEvent(&self, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS) -> ::windows_core::Result; fn BeginGetEvent(&self, pcallback: ::core::option::Option<&IMFAsyncCallback>, punkstate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn EndGetEvent(&self, presult: ::core::option::Option<&IMFAsyncResult>) -> ::windows_core::Result; - fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaEventGenerator {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaEventGenerator_Vtbl { pub const fn new, Impl: IMFMediaEventGenerator_Impl, const OFFSET: isize>() -> IMFMediaEventGenerator_Vtbl { unsafe extern "system" fn GetEvent, Impl: IMFMediaEventGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8919,7 +8883,7 @@ impl IMFMediaEventGenerator_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn QueueEvent, Impl: IMFMediaEventGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QueueEvent, Impl: IMFMediaEventGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.QueueEvent(::core::mem::transmute_copy(&met), ::core::mem::transmute_copy(&guidextendedtype), ::core::mem::transmute_copy(&hrstatus), ::core::mem::transmute_copy(&pvvalue)).into() @@ -8936,20 +8900,16 @@ impl IMFMediaEventGenerator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaEventQueue_Impl: Sized { fn GetEvent(&self, dwflags: u32) -> ::windows_core::Result; fn BeginGetEvent(&self, pcallback: ::core::option::Option<&IMFAsyncCallback>, punkstate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn EndGetEvent(&self, presult: ::core::option::Option<&IMFAsyncResult>) -> ::windows_core::Result; fn QueueEvent(&self, pevent: ::core::option::Option<&IMFMediaEvent>) -> ::windows_core::Result<()>; - fn QueueEventParamVar(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn QueueEventParamVar(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn QueueEventParamUnk(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaEventQueue {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaEventQueue_Vtbl { pub const fn new, Impl: IMFMediaEventQueue_Impl, const OFFSET: isize>() -> IMFMediaEventQueue_Vtbl { unsafe extern "system" fn GetEvent, Impl: IMFMediaEventQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwflags: u32, ppevent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8984,7 +8944,7 @@ impl IMFMediaEventQueue_Vtbl { let this = (*this).get_impl(); this.QueueEvent(::windows_core::from_raw_borrowed(&pevent)).into() } - unsafe extern "system" fn QueueEventParamVar, Impl: IMFMediaEventQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QueueEventParamVar, Impl: IMFMediaEventQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.QueueEventParamVar(::core::mem::transmute_copy(&met), ::core::mem::transmute_copy(&guidextendedtype), ::core::mem::transmute_copy(&hrstatus), ::core::mem::transmute_copy(&pvvalue)).into() @@ -9363,12 +9323,10 @@ impl IMFMediaKeys2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaSession_Impl: Sized + IMFMediaEventGenerator_Impl { fn SetTopology(&self, dwsettopologyflags: u32, ptopology: ::core::option::Option<&IMFTopology>) -> ::windows_core::Result<()>; fn ClearTopologies(&self) -> ::windows_core::Result<()>; - fn Start(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Start(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn Stop(&self) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; @@ -9377,9 +9335,7 @@ pub trait IMFMediaSession_Impl: Sized + IMFMediaEventGenerator_Impl { fn GetSessionCapabilities(&self) -> ::windows_core::Result; fn GetFullTopology(&self, dwgetfulltopologyflags: u32, topoid: u64) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaSession {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaSession_Vtbl { pub const fn new, Impl: IMFMediaSession_Impl, const OFFSET: isize>() -> IMFMediaSession_Vtbl { unsafe extern "system" fn SetTopology, Impl: IMFMediaSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwsettopologyflags: u32, ptopology: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9392,7 +9348,7 @@ impl IMFMediaSession_Vtbl { let this = (*this).get_impl(); this.ClearTopologies().into() } - unsafe extern "system" fn Start, Impl: IMFMediaSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Start, Impl: IMFMediaSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Start(::core::mem::transmute_copy(&pguidtimeformat), ::core::mem::transmute_copy(&pvarstartposition)).into() @@ -9637,19 +9593,15 @@ impl IMFMediaSinkPreroll_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaSource_Impl: Sized + IMFMediaEventGenerator_Impl { fn GetCharacteristics(&self) -> ::windows_core::Result; fn CreatePresentationDescriptor(&self) -> ::windows_core::Result; - fn Start(&self, ppresentationdescriptor: ::core::option::Option<&IMFPresentationDescriptor>, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Start(&self, ppresentationdescriptor: ::core::option::Option<&IMFPresentationDescriptor>, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Stop(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaSource {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaSource_Vtbl { pub const fn new, Impl: IMFMediaSource_Impl, const OFFSET: isize>() -> IMFMediaSource_Vtbl { unsafe extern "system" fn GetCharacteristics, Impl: IMFMediaSource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwcharacteristics: *mut u32) -> ::windows_core::HRESULT { @@ -9674,7 +9626,7 @@ impl IMFMediaSource_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Start, Impl: IMFMediaSource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppresentationdescriptor: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Start, Impl: IMFMediaSource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppresentationdescriptor: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Start(::windows_core::from_raw_borrowed(&ppresentationdescriptor), ::core::mem::transmute_copy(&pguidtimeformat), ::core::mem::transmute_copy(&pvarstartposition)).into() @@ -9708,14 +9660,10 @@ impl IMFMediaSource_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaSource2_Impl: Sized + IMFMediaSourceEx_Impl { fn SetMediaType(&self, dwstreamid: u32, pmediatype: ::core::option::Option<&IMFMediaType>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaSource2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaSource2_Vtbl { pub const fn new, Impl: IMFMediaSource2_Impl, const OFFSET: isize>() -> IMFMediaSource2_Vtbl { unsafe extern "system" fn SetMediaType, Impl: IMFMediaSource2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamid: u32, pmediatype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9729,16 +9677,12 @@ impl IMFMediaSource2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaSourceEx_Impl: Sized + IMFMediaSource_Impl { fn GetSourceAttributes(&self) -> ::windows_core::Result; fn GetStreamAttributes(&self, dwstreamidentifier: u32) -> ::windows_core::Result; fn SetD3DManager(&self, pmanager: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaSourceEx {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaSourceEx_Vtbl { pub const fn new, Impl: IMFMediaSourceEx_Impl, const OFFSET: isize>() -> IMFMediaSourceEx_Vtbl { unsafe extern "system" fn GetSourceAttributes, Impl: IMFMediaSourceEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppattributes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9969,16 +9913,12 @@ impl IMFMediaSourceTopologyProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaStream_Impl: Sized + IMFMediaEventGenerator_Impl { fn GetMediaSource(&self) -> ::windows_core::Result; fn GetStreamDescriptor(&self) -> ::windows_core::Result; fn RequestSample(&self, ptoken: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaStream {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaStream_Vtbl { pub const fn new, Impl: IMFMediaStream_Impl, const OFFSET: isize>() -> IMFMediaStream_Vtbl { unsafe extern "system" fn GetMediaSource, Impl: IMFMediaStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmediasource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10019,15 +9959,11 @@ impl IMFMediaStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaStream2_Impl: Sized + IMFMediaStream_Impl { fn SetStreamState(&self, value: MF_STREAM_STATE) -> ::windows_core::Result<()>; fn GetStreamState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaStream2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaStream2_Vtbl { pub const fn new, Impl: IMFMediaStream2_Impl, const OFFSET: isize>() -> IMFMediaStream2_Vtbl { unsafe extern "system" fn SetStreamState, Impl: IMFMediaStream2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: MF_STREAM_STATE) -> ::windows_core::HRESULT { @@ -10140,8 +10076,6 @@ impl IMFMediaTimeRange_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMediaType_Impl: Sized + IMFAttributes_Impl { fn GetMajorType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn IsCompressedFormat(&self) -> ::windows_core::Result; @@ -10149,9 +10083,7 @@ pub trait IMFMediaType_Impl: Sized + IMFAttributes_Impl { fn GetRepresentation(&self, guidrepresentation: &::windows_core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn FreeRepresentation(&self, guidrepresentation: &::windows_core::GUID, pvrepresentation: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMediaType {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMediaType_Vtbl { pub const fn new, Impl: IMFMediaType_Impl, const OFFSET: isize>() -> IMFMediaType_Vtbl { unsafe extern "system" fn GetMajorType, Impl: IMFMediaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidmajortype: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -10289,20 +10221,16 @@ impl IMFMediaTypeHandler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFMetadata_Impl: Sized { fn SetLanguage(&self, pwszrfc1766: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetLanguage(&self) -> ::windows_core::Result<::windows_core::PWSTR>; - fn GetAllLanguages(&self) -> ::windows_core::Result; - fn SetProperty(&self, pwszname: &::windows_core::PCWSTR, ppvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetProperty(&self, pwszname: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetAllLanguages(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetProperty(&self, pwszname: &::windows_core::PCWSTR, ppvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, pwszname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn DeleteProperty(&self, pwszname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn GetAllPropertyNames(&self) -> ::windows_core::Result; + fn GetAllPropertyNames(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFMetadata {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFMetadata_Vtbl { pub const fn new, Impl: IMFMetadata_Impl, const OFFSET: isize>() -> IMFMetadata_Vtbl { unsafe extern "system" fn SetLanguage, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszrfc1766: ::windows_core::PCWSTR) -> ::windows_core::HRESULT { @@ -10321,7 +10249,7 @@ impl IMFMetadata_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetAllLanguages, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppvlanguages: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAllLanguages, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppvlanguages: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAllLanguages() { @@ -10332,12 +10260,12 @@ impl IMFMetadata_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&pwszname), ::core::mem::transmute_copy(&ppvvalue)).into() } - unsafe extern "system" fn GetProperty, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&pwszname)) { @@ -10353,7 +10281,7 @@ impl IMFMetadata_Vtbl { let this = (*this).get_impl(); this.DeleteProperty(::core::mem::transmute(&pwszname)).into() } - unsafe extern "system" fn GetAllPropertyNames, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppvnames: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAllPropertyNames, Impl: IMFMetadata_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppvnames: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAllPropertyNames() { @@ -10929,16 +10857,12 @@ impl IMFObjectReferenceStream_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFOutputPolicy_Impl: Sized + IMFAttributes_Impl { fn GenerateRequiredSchemas(&self, dwattributes: u32, guidoutputsubtype: &::windows_core::GUID, rgguidprotectionschemassupported: *const ::windows_core::GUID, cprotectionschemassupported: u32) -> ::windows_core::Result; fn GetOriginatorID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetMinimumGRLVersion(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFOutputPolicy {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFOutputPolicy_Vtbl { pub const fn new, Impl: IMFOutputPolicy_Impl, const OFFSET: isize>() -> IMFOutputPolicy_Vtbl { unsafe extern "system" fn GenerateRequiredSchemas, Impl: IMFOutputPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwattributes: u32, guidoutputsubtype: ::windows_core::GUID, rgguidprotectionschemassupported: *const ::windows_core::GUID, cprotectionschemassupported: u32, pprequiredprotectionschemas: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10985,16 +10909,12 @@ impl IMFOutputPolicy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFOutputSchema_Impl: Sized + IMFAttributes_Impl { fn GetSchemaType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetConfigurationData(&self) -> ::windows_core::Result; fn GetOriginatorID(&self) -> ::windows_core::Result<::windows_core::GUID>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFOutputSchema {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFOutputSchema_Vtbl { pub const fn new, Impl: IMFOutputSchema_Impl, const OFFSET: isize>() -> IMFOutputSchema_Vtbl { unsafe extern "system" fn GetSchemaType, Impl: IMFOutputSchema_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidschematype: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -11218,32 +11138,32 @@ impl IMFPMPServer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IMFPMediaItem_Impl: Sized { fn GetMediaPlayer(&self) -> ::windows_core::Result; fn GetURL(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetObject(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetUserData(&self) -> ::windows_core::Result; fn SetUserData(&self, dwuserdata: usize) -> ::windows_core::Result<()>; - fn GetStartStopPosition(&self, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn SetStartStopPosition(&self, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetStartStopPosition(&self, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut ::windows_core::PROPVARIANT, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetStartStopPosition(&self, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const ::windows_core::PROPVARIANT, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn HasVideo(&self, pfhasvideo: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn HasAudio(&self, pfhasaudio: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn IsProtected(&self) -> ::windows_core::Result; - fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetNumberOfStreams(&self) -> ::windows_core::Result; fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows_core::Result; fn SetStreamSelection(&self, dwstreamindex: u32, fenabled: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetCharacteristics(&self) -> ::windows_core::Result; fn SetStreamSink(&self, dwstreamindex: u32, pmediasink: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn GetMetadata(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IMFPMediaItem {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IMFPMediaItem_Vtbl { pub const fn new, Impl: IMFPMediaItem_Impl, const OFFSET: isize>() -> IMFPMediaItem_Vtbl { unsafe extern "system" fn GetMediaPlayer, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmediaplayer: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -11295,12 +11215,12 @@ impl IMFPMediaItem_Vtbl { let this = (*this).get_impl(); this.SetUserData(::core::mem::transmute_copy(&dwuserdata)).into() } - unsafe extern "system" fn GetStartStopPosition, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStartStopPosition, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetStartStopPosition(::core::mem::transmute_copy(&pguidstartpositiontype), ::core::mem::transmute_copy(&pvstartvalue), ::core::mem::transmute_copy(&pguidstoppositiontype), ::core::mem::transmute_copy(&pvstopvalue)).into() } - unsafe extern "system" fn SetStartStopPosition, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetStartStopPosition, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetStartStopPosition(::core::mem::transmute_copy(&pguidstartpositiontype), ::core::mem::transmute_copy(&pvstartvalue), ::core::mem::transmute_copy(&pguidstoppositiontype), ::core::mem::transmute_copy(&pvstopvalue)).into() @@ -11326,7 +11246,7 @@ impl IMFPMediaItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDuration, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDuration, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDuration(::core::mem::transmute_copy(&guidpositiontype)) { @@ -11364,7 +11284,7 @@ impl IMFPMediaItem_Vtbl { let this = (*this).get_impl(); this.SetStreamSelection(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&fenabled)).into() } - unsafe extern "system" fn GetStreamAttribute, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStreamAttribute, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStreamAttribute(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&guidmfattribute)) { @@ -11375,7 +11295,7 @@ impl IMFPMediaItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPresentationAttribute, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPresentationAttribute, Impl: IMFPMediaItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPresentationAttribute(::core::mem::transmute_copy(&guidmfattribute)) { @@ -11440,16 +11360,14 @@ impl IMFPMediaItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFPMediaPlayer_Impl: Sized { fn Play(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn Stop(&self) -> ::windows_core::Result<()>; fn FrameStep(&self) -> ::windows_core::Result<()>; - fn SetPosition(&self, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetPosition(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result; + fn SetPosition(&self, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetPosition(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn SetRate(&self, flrate: f32) -> ::windows_core::Result<()>; fn GetRate(&self) -> ::windows_core::Result; fn GetSupportedRates(&self, fforwarddirection: super::super::Foundation::BOOL, pflslowestrate: *mut f32, pflfastestrate: *mut f32) -> ::windows_core::Result<()>; @@ -11480,9 +11398,7 @@ pub trait IMFPMediaPlayer_Impl: Sized { fn RemoveAllEffects(&self) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFPMediaPlayer {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFPMediaPlayer_Vtbl { pub const fn new, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>() -> IMFPMediaPlayer_Vtbl { unsafe extern "system" fn Play, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -11505,12 +11421,12 @@ impl IMFPMediaPlayer_Vtbl { let this = (*this).get_impl(); this.FrameStep().into() } - unsafe extern "system" fn SetPosition, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPosition, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPosition(::core::mem::transmute_copy(&guidpositiontype), ::core::mem::transmute_copy(&pvpositionvalue)).into() } - unsafe extern "system" fn GetPosition, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPosition, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPosition(::core::mem::transmute_copy(&guidpositiontype)) { @@ -11521,7 +11437,7 @@ impl IMFPMediaPlayer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDuration, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDuration, Impl: IMFPMediaPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDuration(::core::mem::transmute_copy(&guidpositiontype)) { @@ -11967,8 +11883,6 @@ impl IMFPresentationClock_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFPresentationDescriptor_Impl: Sized + IMFAttributes_Impl { fn GetStreamDescriptorCount(&self) -> ::windows_core::Result; fn GetStreamDescriptorByIndex(&self, dwindex: u32, pfselected: *mut super::super::Foundation::BOOL, ppdescriptor: *mut ::core::option::Option) -> ::windows_core::Result<()>; @@ -11976,9 +11890,7 @@ pub trait IMFPresentationDescriptor_Impl: Sized + IMFAttributes_Impl { fn DeselectStream(&self, dwdescriptorindex: u32) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFPresentationDescriptor {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFPresentationDescriptor_Vtbl { pub const fn new, Impl: IMFPresentationDescriptor_Impl, const OFFSET: isize>() -> IMFPresentationDescriptor_Vtbl { unsafe extern "system" fn GetStreamDescriptorCount, Impl: IMFPresentationDescriptor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwdescriptorcount: *mut u32) -> ::windows_core::HRESULT { @@ -12556,17 +12468,13 @@ impl IMFRemoteProxy_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSAMIStyle_Impl: Sized { fn GetStyleCount(&self) -> ::windows_core::Result; - fn GetStyles(&self) -> ::windows_core::Result; + fn GetStyles(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn SetSelectedStyle(&self, pwszstyle: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetSelectedStyle(&self) -> ::windows_core::Result<::windows_core::PWSTR>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSAMIStyle {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSAMIStyle_Vtbl { pub const fn new, Impl: IMFSAMIStyle_Impl, const OFFSET: isize>() -> IMFSAMIStyle_Vtbl { unsafe extern "system" fn GetStyleCount, Impl: IMFSAMIStyle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT { @@ -12580,7 +12488,7 @@ impl IMFSAMIStyle_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetStyles, Impl: IMFSAMIStyle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarstylearray: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStyles, Impl: IMFSAMIStyle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarstylearray: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStyles() { @@ -12673,8 +12581,6 @@ impl IMFSSLCertificateManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSample_Impl: Sized + IMFAttributes_Impl { fn GetSampleFlags(&self) -> ::windows_core::Result; fn SetSampleFlags(&self, dwsampleflags: u32) -> ::windows_core::Result<()>; @@ -12691,9 +12597,7 @@ pub trait IMFSample_Impl: Sized + IMFAttributes_Impl { fn GetTotalLength(&self) -> ::windows_core::Result; fn CopyToBuffer(&self, pbuffer: ::core::option::Option<&IMFMediaBuffer>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSample {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSample_Vtbl { pub const fn new, Impl: IMFSample_Impl, const OFFSET: isize>() -> IMFSample_Vtbl { unsafe extern "system" fn GetSampleFlags, Impl: IMFSample_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwsampleflags: *mut u32) -> ::windows_core::HRESULT { @@ -13137,17 +13041,13 @@ impl IMFSecureChannel_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSeekInfo_Impl: Sized { - fn GetNearestKeyFrames(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarpreviouskeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarnextkeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetNearestKeyFrames(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT, pvarpreviouskeyframe: *mut ::windows_core::PROPVARIANT, pvarnextkeyframe: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSeekInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSeekInfo_Vtbl { pub const fn new, Impl: IMFSeekInfo_Impl, const OFFSET: isize>() -> IMFSeekInfo_Vtbl { - unsafe extern "system" fn GetNearestKeyFrames, Impl: IMFSeekInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarpreviouskeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarnextkeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetNearestKeyFrames, Impl: IMFSeekInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarpreviouskeyframe: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarnextkeyframe: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetNearestKeyFrames(::core::mem::transmute_copy(&pguidtimeformat), ::core::mem::transmute_copy(&pvarstartposition), ::core::mem::transmute_copy(&pvarpreviouskeyframe), ::core::mem::transmute_copy(&pvarnextkeyframe)).into() @@ -13705,16 +13605,12 @@ impl IMFSensorProfileCollection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSensorStream_Impl: Sized + IMFAttributes_Impl { fn GetMediaTypeCount(&self) -> ::windows_core::Result; fn GetMediaType(&self, dwindex: u32) -> ::windows_core::Result; fn CloneSensorStream(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSensorStream {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSensorStream_Vtbl { pub const fn new, Impl: IMFSensorStream_Impl, const OFFSET: isize>() -> IMFSensorStream_Vtbl { unsafe extern "system" fn GetMediaTypeCount, Impl: IMFSensorStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT { @@ -14423,23 +14319,19 @@ impl IMFSourceOpenMonitor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSourceReader_Impl: Sized { fn GetStreamSelection(&self, dwstreamindex: u32) -> ::windows_core::Result; fn SetStreamSelection(&self, dwstreamindex: u32, fselected: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetNativeMediaType(&self, dwstreamindex: u32, dwmediatypeindex: u32) -> ::windows_core::Result; fn GetCurrentMediaType(&self, dwstreamindex: u32) -> ::windows_core::Result; fn SetCurrentMediaType(&self, dwstreamindex: u32, pdwreserved: *const u32, pmediatype: ::core::option::Option<&IMFMediaType>) -> ::windows_core::Result<()>; - fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn ReadSample(&self, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn Flush(&self, dwstreamindex: u32) -> ::windows_core::Result<()>; fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSourceReader {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSourceReader_Vtbl { pub const fn new, Impl: IMFSourceReader_Impl, const OFFSET: isize>() -> IMFSourceReader_Vtbl { unsafe extern "system" fn GetStreamSelection, Impl: IMFSourceReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, pfselected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -14485,7 +14377,7 @@ impl IMFSourceReader_Vtbl { let this = (*this).get_impl(); this.SetCurrentMediaType(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&pdwreserved), ::windows_core::from_raw_borrowed(&pmediatype)).into() } - unsafe extern "system" fn SetCurrentPosition, Impl: IMFSourceReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidtimeformat: *const ::windows_core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCurrentPosition, Impl: IMFSourceReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guidtimeformat: *const ::windows_core::GUID, varposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCurrentPosition(::core::mem::transmute_copy(&guidtimeformat), ::core::mem::transmute_copy(&varposition)).into() @@ -14505,7 +14397,7 @@ impl IMFSourceReader_Vtbl { let this = (*this).get_impl(); this.GetServiceForStream(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&guidservice), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppvobject)).into() } - unsafe extern "system" fn GetPresentationAttribute, Impl: IMFSourceReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID, pvarattribute: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPresentationAttribute, Impl: IMFSourceReader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID, pvarattribute: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPresentationAttribute(::core::mem::transmute_copy(&dwstreamindex), ::core::mem::transmute_copy(&guidattribute)) { @@ -14595,17 +14487,13 @@ impl IMFSourceReaderCallback2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSourceReaderEx_Impl: Sized + IMFSourceReader_Impl { fn SetNativeMediaType(&self, dwstreamindex: u32, pmediatype: ::core::option::Option<&IMFMediaType>) -> ::windows_core::Result; fn AddTransformForStream(&self, dwstreamindex: u32, ptransformoractivate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn RemoveAllTransformsForStream(&self, dwstreamindex: u32) -> ::windows_core::Result<()>; fn GetTransformForStream(&self, dwstreamindex: u32, dwtransformindex: u32, pguidcategory: *mut ::windows_core::GUID, pptransform: *mut ::core::option::Option) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSourceReaderEx {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSourceReaderEx_Vtbl { pub const fn new, Impl: IMFSourceReaderEx_Impl, const OFFSET: isize>() -> IMFSourceReaderEx_Vtbl { unsafe extern "system" fn SetNativeMediaType, Impl: IMFSourceReaderEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwstreamindex: u32, pmediatype: *mut ::core::ffi::c_void, pdwstreamflags: *mut u32) -> ::windows_core::HRESULT { @@ -14782,16 +14670,12 @@ impl IMFSpatialAudioObjectBuffer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFSpatialAudioSample_Impl: Sized + IMFSample_Impl { fn GetObjectCount(&self) -> ::windows_core::Result; fn AddSpatialAudioObject(&self, paudioobjbuffer: ::core::option::Option<&IMFSpatialAudioObjectBuffer>) -> ::windows_core::Result<()>; fn GetSpatialAudioObjectByIndex(&self, dwindex: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFSpatialAudioSample {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFSpatialAudioSample_Vtbl { pub const fn new, Impl: IMFSpatialAudioSample_Impl, const OFFSET: isize>() -> IMFSpatialAudioSample_Vtbl { unsafe extern "system" fn GetObjectCount, Impl: IMFSpatialAudioSample_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwobjectcount: *mut u32) -> ::windows_core::HRESULT { @@ -14832,15 +14716,11 @@ impl IMFSpatialAudioSample_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFStreamDescriptor_Impl: Sized + IMFAttributes_Impl { fn GetStreamIdentifier(&self) -> ::windows_core::Result; fn GetMediaTypeHandler(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFStreamDescriptor {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFStreamDescriptor_Vtbl { pub const fn new, Impl: IMFStreamDescriptor_Impl, const OFFSET: isize>() -> IMFStreamDescriptor_Vtbl { unsafe extern "system" fn GetStreamIdentifier, Impl: IMFStreamDescriptor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwstreamidentifier: *mut u32) -> ::windows_core::HRESULT { @@ -14875,19 +14755,15 @@ impl IMFStreamDescriptor_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFStreamSink_Impl: Sized + IMFMediaEventGenerator_Impl { fn GetMediaSink(&self) -> ::windows_core::Result; fn GetIdentifier(&self) -> ::windows_core::Result; fn GetMediaTypeHandler(&self) -> ::windows_core::Result; fn ProcessSample(&self, psample: ::core::option::Option<&IMFSample>) -> ::windows_core::Result<()>; - fn PlaceMarker(&self, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarcontextvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn PlaceMarker(&self, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const ::windows_core::PROPVARIANT, pvarcontextvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Flush(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFStreamSink {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFStreamSink_Vtbl { pub const fn new, Impl: IMFStreamSink_Impl, const OFFSET: isize>() -> IMFStreamSink_Vtbl { unsafe extern "system" fn GetMediaSink, Impl: IMFStreamSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmediasink: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14928,7 +14804,7 @@ impl IMFStreamSink_Vtbl { let this = (*this).get_impl(); this.ProcessSample(::windows_core::from_raw_borrowed(&psample)).into() } - unsafe extern "system" fn PlaceMarker, Impl: IMFStreamSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarcontextvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlaceMarker, Impl: IMFStreamSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarcontextvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PlaceMarker(::core::mem::transmute_copy(&emarkertype), ::core::mem::transmute_copy(&pvarmarkervalue), ::core::mem::transmute_copy(&pvarcontextvalue)).into() @@ -14996,20 +14872,16 @@ impl IMFSystemId_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFTimecodeTranslate_Impl: Sized { - fn BeginConvertTimecodeToHNS(&self, ppropvartimecode: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pcallback: ::core::option::Option<&IMFAsyncCallback>, punkstate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; + fn BeginConvertTimecodeToHNS(&self, ppropvartimecode: *const ::windows_core::PROPVARIANT, pcallback: ::core::option::Option<&IMFAsyncCallback>, punkstate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn EndConvertTimecodeToHNS(&self, presult: ::core::option::Option<&IMFAsyncResult>) -> ::windows_core::Result; fn BeginConvertHNSToTimecode(&self, hnstime: i64, pcallback: ::core::option::Option<&IMFAsyncCallback>, punkstate: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; - fn EndConvertHNSToTimecode(&self, presult: ::core::option::Option<&IMFAsyncResult>) -> ::windows_core::Result; + fn EndConvertHNSToTimecode(&self, presult: ::core::option::Option<&IMFAsyncResult>) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFTimecodeTranslate {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFTimecodeTranslate_Vtbl { pub const fn new, Impl: IMFTimecodeTranslate_Impl, const OFFSET: isize>() -> IMFTimecodeTranslate_Vtbl { - unsafe extern "system" fn BeginConvertTimecodeToHNS, Impl: IMFTimecodeTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvartimecode: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginConvertTimecodeToHNS, Impl: IMFTimecodeTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvartimecode: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.BeginConvertTimecodeToHNS(::core::mem::transmute_copy(&ppropvartimecode), ::windows_core::from_raw_borrowed(&pcallback), ::windows_core::from_raw_borrowed(&punkstate)).into() @@ -15030,7 +14902,7 @@ impl IMFTimecodeTranslate_Vtbl { let this = (*this).get_impl(); this.BeginConvertHNSToTimecode(::core::mem::transmute_copy(&hnstime), ::windows_core::from_raw_borrowed(&pcallback), ::windows_core::from_raw_borrowed(&punkstate)).into() } - unsafe extern "system" fn EndConvertHNSToTimecode, Impl: IMFTimecodeTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppropvartimecode: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EndConvertHNSToTimecode, Impl: IMFTimecodeTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppropvartimecode: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EndConvertHNSToTimecode(::windows_core::from_raw_borrowed(&presult)) { @@ -16252,8 +16124,6 @@ impl IMFTopoLoader_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFTopology_Impl: Sized + IMFAttributes_Impl { fn GetTopologyID(&self) -> ::windows_core::Result; fn AddNode(&self, pnode: ::core::option::Option<&IMFTopologyNode>) -> ::windows_core::Result<()>; @@ -16266,9 +16136,7 @@ pub trait IMFTopology_Impl: Sized + IMFAttributes_Impl { fn GetSourceNodeCollection(&self) -> ::windows_core::Result; fn GetOutputNodeCollection(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFTopology {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFTopology_Vtbl { pub const fn new, Impl: IMFTopology_Impl, const OFFSET: isize>() -> IMFTopology_Vtbl { unsafe extern "system" fn GetTopologyID, Impl: IMFTopology_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut u64) -> ::windows_core::HRESULT { @@ -16375,8 +16243,6 @@ impl IMFTopology_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFTopologyNode_Impl: Sized + IMFAttributes_Impl { fn SetObject(&self, pobject: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn GetObject(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -16395,9 +16261,7 @@ pub trait IMFTopologyNode_Impl: Sized + IMFAttributes_Impl { fn GetInputPrefType(&self, dwinputindex: u32) -> ::windows_core::Result; fn CloneFrom(&self, pnode: ::core::option::Option<&IMFTopologyNode>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFTopologyNode {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFTopologyNode_Vtbl { pub const fn new, Impl: IMFTopologyNode_Impl, const OFFSET: isize>() -> IMFTopologyNode_Vtbl { unsafe extern "system" fn SetObject, Impl: IMFTopologyNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobject: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17255,15 +17119,11 @@ impl IMFVideoDisplayControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IMFVideoMediaType_Impl: Sized + IMFMediaType_Impl { fn GetVideoFormat(&self) -> *mut MFVIDEOFORMAT; fn GetVideoRepresentation(&self, guidrepresentation: &::windows_core::GUID, ppvrepresentation: *mut *mut ::core::ffi::c_void, lstride: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IMFVideoMediaType {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IMFVideoMediaType_Vtbl { pub const fn new, Impl: IMFVideoMediaType_Impl, const OFFSET: isize>() -> IMFVideoMediaType_Vtbl { unsafe extern "system" fn GetVideoFormat, Impl: IMFVideoMediaType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> *mut MFVIDEOFORMAT { @@ -17920,8 +17780,8 @@ impl IMFVideoSampleAllocatorNotifyEx_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Devices_Properties\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Devices_Properties\"`"] +#[cfg(feature = "Win32_Devices_Properties")] pub trait IMFVirtualCamera_Impl: Sized + IMFAttributes_Impl { fn AddDeviceSourceInfo(&self, devicesourceinfo: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn AddProperty(&self, pkey: *const super::super::Devices::Properties::DEVPROPKEY, r#type: super::super::Devices::Properties::DEVPROPTYPE, pbdata: *const u8, cbdata: u32) -> ::windows_core::Result<()>; @@ -17935,9 +17795,9 @@ pub trait IMFVirtualCamera_Impl: Sized + IMFAttributes_Impl { fn CreateSyncSemaphore(&self, kseventset: *const ::windows_core::GUID, kseventid: u32, kseventflags: u32, semaphorehandle: super::super::Foundation::HANDLE, semaphoreadjustment: i32) -> ::windows_core::Result; fn Shutdown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Devices_Properties")] impl ::windows_core::RuntimeName for IMFVirtualCamera {} -#[cfg(all(feature = "Win32_Devices_Properties", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Devices_Properties")] impl IMFVirtualCamera_Vtbl { pub const fn new, Impl: IMFVirtualCamera_Impl, const OFFSET: isize>() -> IMFVirtualCamera_Vtbl { unsafe extern "system" fn AddDeviceSourceInfo, Impl: IMFVirtualCamera_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, devicesourceinfo: ::windows_core::PCWSTR) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/mod.rs index a6d6e8037e..c3dc23f937 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/MediaFoundation/mod.rs @@ -628,11 +628,9 @@ where let mut result__ = ::std::mem::zeroed(); MFCreateMediaBufferWrapper(pbuffer.into_param().abi(), cboffset, dwlength, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn MFCreateMediaEvent(met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result { - ::windows_targets::link!("mfplat.dll" "system" fn MFCreateMediaEvent(met : u32, guidextendedtype : *const ::windows_core::GUID, hrstatus : ::windows_core::HRESULT, pvvalue : *const super::super::System::Com::StructuredStorage:: PROPVARIANT, ppevent : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); +pub unsafe fn MFCreateMediaEvent(met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result { + ::windows_targets::link!("mfplat.dll" "system" fn MFCreateMediaEvent(met : u32, guidextendedtype : *const ::windows_core::GUID, hrstatus : ::windows_core::HRESULT, pvvalue : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ppevent : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); MFCreateMediaEvent(met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue.unwrap_or(::std::ptr::null())), &mut result__).from_abi(result__) } @@ -865,11 +863,9 @@ where let mut result__ = ::std::mem::zeroed(); MFCreateSensorStream(streamid, pattributes.into_param().abi(), pmediatypecollection.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn MFCreateSequencerSegmentOffset(dwid: u32, hnsoffset: i64) -> ::windows_core::Result { - ::windows_targets::link!("mf.dll" "system" fn MFCreateSequencerSegmentOffset(dwid : u32, hnsoffset : i64, pvarsegmentoffset : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn MFCreateSequencerSegmentOffset(dwid: u32, hnsoffset: i64) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("mf.dll" "system" fn MFCreateSequencerSegmentOffset(dwid : u32, hnsoffset : i64, pvarsegmentoffset : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); MFCreateSequencerSegmentOffset(dwid, hnsoffset, &mut result__).from_abi(result__) } @@ -1322,19 +1318,15 @@ pub unsafe fn MFGetStrideForBitmapInfoHeader(format: u32, dwwidth: u32) -> ::win let mut result__ = ::std::mem::zeroed(); MFGetStrideForBitmapInfoHeader(format, dwwidth, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn MFGetSupportedMimeTypes() -> ::windows_core::Result { - ::windows_targets::link!("mfplat.dll" "system" fn MFGetSupportedMimeTypes(ppropvarmimetypearray : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn MFGetSupportedMimeTypes() -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("mfplat.dll" "system" fn MFGetSupportedMimeTypes(ppropvarmimetypearray : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); MFGetSupportedMimeTypes(&mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn MFGetSupportedSchemes() -> ::windows_core::Result { - ::windows_targets::link!("mfplat.dll" "system" fn MFGetSupportedSchemes(ppropvarschemearray : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn MFGetSupportedSchemes() -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("mfplat.dll" "system" fn MFGetSupportedSchemes(ppropvarschemearray : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); MFGetSupportedSchemes(&mut result__).from_abi(result__) } @@ -1989,32 +1981,22 @@ impl ICodecAPI { pub unsafe fn IsModifiable(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsModifiable)(::windows_core::Interface::as_raw(self), api).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetParameterRange)(::windows_core::Interface::as_raw(self), api, valuemin, valuemax, steppingdelta).ok() + pub unsafe fn GetParameterRange(&self, api: *const ::windows_core::GUID, valuemin: *mut ::windows_core::VARIANT, valuemax: *mut ::windows_core::VARIANT, steppingdelta: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetParameterRange)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(valuemin), ::core::mem::transmute(valuemax), ::core::mem::transmute(steppingdelta)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn GetParameterValues(&self, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetParameterValues)(::windows_core::Interface::as_raw(self), api, values, valuescount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetDefaultValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDefaultValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetValue(&self, api: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), api, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), api, value).ok() + pub unsafe fn SetValue(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(value)).ok() } pub unsafe fn RegisterForEvent(&self, api: *const ::windows_core::GUID, userdata: isize) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RegisterForEvent)(::windows_core::Interface::as_raw(self), api, userdata).ok() @@ -2025,10 +2007,8 @@ impl ICodecAPI { pub unsafe fn SetAllDefaults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetAllDefaults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValueWithNotify(&self, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValueWithNotify)(::windows_core::Interface::as_raw(self), api, value, changedparam, changedparamcount).ok() + pub unsafe fn SetValueWithNotify(&self, api: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValueWithNotify)(::windows_core::Interface::as_raw(self), api, ::core::mem::transmute(value), changedparam, changedparamcount).ok() } pub unsafe fn SetAllDefaultsWithNotify(&self, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetAllDefaultsWithNotify)(::windows_core::Interface::as_raw(self), changedparam, changedparamcount).ok() @@ -2064,33 +2044,15 @@ pub struct ICodecAPI_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub IsSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT, pub IsModifiable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameterRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut super::super::System::Variant::VARIANT, valuemax: *mut super::super::System::Variant::VARIANT, steppingdelta: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameterRange: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameterValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut super::super::System::Variant::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameterValues: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDefaultValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub GetParameterRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, valuemin: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, valuemax: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, steppingdelta: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetParameterValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, values: *mut *mut ::windows_core::VARIANT, valuescount: *mut u32) -> ::windows_core::HRESULT, + pub GetDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RegisterForEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, userdata: isize) -> ::windows_core::HRESULT, pub UnregisterForEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID) -> ::windows_core::HRESULT, pub SetAllDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValueWithNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const super::super::System::Variant::VARIANT, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValueWithNotify: usize, + pub SetValueWithNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, api: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::HRESULT, pub SetAllDefaultsWithNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, changedparam: *mut *mut ::windows_core::GUID, changedparamcount: *mut u32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetAllSettings: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, __midl__icodecapi0000: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -6433,10 +6395,8 @@ impl IMFASFIndexer { { (::windows_core::Interface::vtable(self).SetIndexStatus)(::windows_core::Interface::as_raw(self), pbindexdescriptor, cbindexdescriptor, fgenerateindex.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetSeekPositionForValue(&self, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetSeekPositionForValue)(::windows_core::Interface::as_raw(self), pvarvalue, pindexidentifier, pcboffsetwithindata, phnsapproxtime, pdwpayloadnumberofstreamwithinpacket).ok() + pub unsafe fn GetSeekPositionForValue(&self, pvarvalue: *const ::windows_core::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetSeekPositionForValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvalue), pindexidentifier, pcboffsetwithindata, phnsapproxtime, pdwpayloadnumberofstreamwithinpacket).ok() } pub unsafe fn GenerateIndexEntries(&self, piasfpacketsample: P0) -> ::windows_core::Result<()> where @@ -6473,10 +6433,7 @@ pub struct IMFASFIndexer_Vtbl { pub GetIndexByteStreamCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbytestreams: *mut u32) -> ::windows_core::HRESULT, pub GetIndexStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pfisindexed: *mut super::super::Foundation::BOOL, pbindexdescriptor: *mut u8, pcbindexdescriptor: *mut u32) -> ::windows_core::HRESULT, pub SetIndexStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbindexdescriptor: *const u8, cbindexdescriptor: u32, fgenerateindex: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetSeekPositionForValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetSeekPositionForValue: usize, + pub GetSeekPositionForValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pindexidentifier: *const ASF_INDEX_IDENTIFIER, pcboffsetwithindata: *mut u64, phnsapproxtime: *mut i64, pdwpayloadnumberofstreamwithinpacket: *mut u32) -> ::windows_core::HRESULT, pub GenerateIndexEntries: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, piasfpacketsample: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CommitIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, picontentinfo: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetIndexWriteSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbindexwritespace: *mut u64) -> ::windows_core::HRESULT, @@ -6590,20 +6547,16 @@ pub struct IMFASFMutualExclusion_Vtbl { ::windows_core::imp::com_interface!(IMFASFProfile, IMFASFProfile_Vtbl, 0xd267bf6a_028b_4e0d_903d_43f0ef82d0d4); ::windows_core::imp::interface_hierarchy!(IMFASFProfile, ::windows_core::IUnknown, IMFAttributes); impl IMFASFProfile { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -6655,10 +6608,8 @@ impl IMFASFProfile { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -6703,9 +6654,7 @@ impl IMFASFProfile { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -6861,20 +6810,16 @@ pub struct IMFASFSplitter_Vtbl { ::windows_core::imp::com_interface!(IMFASFStreamConfig, IMFASFStreamConfig_Vtbl, 0x9e8ae8d2_dbbd_4200_9aca_06e6df484913); ::windows_core::imp::interface_hierarchy!(IMFASFStreamConfig, ::windows_core::IUnknown, IMFAttributes); impl IMFASFStreamConfig { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -6926,10 +6871,8 @@ impl IMFASFStreamConfig { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -6974,9 +6917,7 @@ impl IMFASFStreamConfig { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -7147,20 +7088,16 @@ pub struct IMFASFStreamSelector_Vtbl { ::windows_core::imp::com_interface!(IMFActivate, IMFActivate_Vtbl, 0x7fee9e9a_4a89_47a6_899c_b6a53a70fb67); ::windows_core::imp::interface_hierarchy!(IMFActivate, ::windows_core::IUnknown, IMFAttributes); impl IMFActivate { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -7212,10 +7149,8 @@ impl IMFActivate { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -7260,9 +7195,7 @@ impl IMFActivate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -7373,20 +7306,16 @@ pub struct IMFAsyncResult_Vtbl { ::windows_core::imp::com_interface!(IMFAttributes, IMFAttributes_Vtbl, 0x2cd2d921_c447_44a7_a13c_4adabfc247e3); ::windows_core::imp::interface_hierarchy!(IMFAttributes, ::windows_core::IUnknown); impl IMFAttributes { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -7438,10 +7367,8 @@ impl IMFAttributes { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -7486,9 +7413,7 @@ impl IMFAttributes { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -7502,15 +7427,9 @@ impl IMFAttributes { #[doc(hidden)] pub struct IMFAttributes_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetItem: usize, + pub GetItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetItemType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, ptype: *mut MF_ATTRIBUTE_TYPE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub CompareItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pbresult: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - CompareItem: usize, + pub CompareItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pbresult: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Compare: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptheirs: *mut ::core::ffi::c_void, matchtype: MF_ATTRIBUTES_MATCH_TYPE, pbresult: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub GetUINT32: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, punvalue: *mut u32) -> ::windows_core::HRESULT, pub GetUINT64: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, punvalue: *mut u64) -> ::windows_core::HRESULT, @@ -7523,10 +7442,7 @@ pub struct IMFAttributes_Vtbl { pub GetBlob: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, pbuf: *mut u8, cbbufsize: u32, pcbblobsize: *mut u32) -> ::windows_core::HRESULT, pub GetAllocatedBlob: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, ppbuf: *mut *mut u8, pcbsize: *mut u32) -> ::windows_core::HRESULT, pub GetUnknown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetItem: usize, + pub SetItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID) -> ::windows_core::HRESULT, pub DeleteAllItems: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetUINT32: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidkey: *const ::windows_core::GUID, unvalue: u32) -> ::windows_core::HRESULT, @@ -7539,29 +7455,22 @@ pub struct IMFAttributes_Vtbl { pub LockStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub UnlockStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcitems: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetItemByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetItemByIndex: usize, + pub GetItemByIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub CopyAllItems: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdest: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFAudioMediaType, IMFAudioMediaType_Vtbl, 0x26a0adc3_ce26_4672_9304_69552edd3faf); ::windows_core::imp::interface_hierarchy!(IMFAudioMediaType, ::windows_core::IUnknown, IMFAttributes, IMFMediaType); impl IMFAudioMediaType { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -7613,10 +7522,8 @@ impl IMFAudioMediaType { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -7661,9 +7568,7 @@ impl IMFAudioMediaType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -8093,20 +7998,16 @@ pub struct IMFCameraControlDefaults_Vtbl { ::windows_core::imp::com_interface!(IMFCameraControlDefaultsCollection, IMFCameraControlDefaultsCollection_Vtbl, 0x92d43d0f_54a8_4bae_96da_356d259a5c26); ::windows_core::imp::interface_hierarchy!(IMFCameraControlDefaultsCollection, ::windows_core::IUnknown, IMFAttributes); impl IMFCameraControlDefaultsCollection { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -8158,10 +8059,8 @@ impl IMFCameraControlDefaultsCollection { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -8206,9 +8105,7 @@ impl IMFCameraControlDefaultsCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -10753,9 +10650,7 @@ impl IMFMediaEngineEx { { (::windows_core::Interface::vtable(self).SetSourceFromByteStream)(::windows_core::Interface::as_raw(self), pbytestream.into_param().abi(), purl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetStatistics(&self, statisticid: MF_MEDIA_ENGINE_STATISTIC) -> ::windows_core::Result { + pub unsafe fn GetStatistics(&self, statisticid: MF_MEDIA_ENGINE_STATISTIC) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStatistics)(::windows_core::Interface::as_raw(self), statisticid, &mut result__).from_abi(result__) } @@ -10781,9 +10676,7 @@ impl IMFMediaEngineEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetResourceCharacteristics)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPresentationAttribute)(::windows_core::Interface::as_raw(self), guidmfattribute, &mut result__).from_abi(result__) } @@ -10791,9 +10684,7 @@ impl IMFMediaEngineEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetNumberOfStreams)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStreamAttribute)(::windows_core::Interface::as_raw(self), dwstreamindex, guidmfattribute, &mut result__).from_abi(result__) } @@ -10913,25 +10804,16 @@ impl IMFMediaEngineEx { pub struct IMFMediaEngineEx_Vtbl { pub base__: IMFMediaEngine_Vtbl, pub SetSourceFromByteStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbytestream: *mut ::core::ffi::c_void, purl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetStatistics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, statisticid: MF_MEDIA_ENGINE_STATISTIC, pstatistic: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetStatistics: usize, + pub GetStatistics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, statisticid: MF_MEDIA_ENGINE_STATISTIC, pstatistic: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub UpdateVideoStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psrc: *const MFVideoNormalizedRect, pdst: *const super::super::Foundation::RECT, pborderclr: *const MFARGB) -> ::windows_core::HRESULT, pub GetBalance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> f64, pub SetBalance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, balance: f64) -> ::windows_core::HRESULT, pub IsPlaybackRateSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rate: f64) -> super::super::Foundation::BOOL, pub FrameStep: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, forward: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub GetResourceCharacteristics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcharacteristics: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetPresentationAttribute: usize, + pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetNumberOfStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwstreamcount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetStreamAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetStreamAttribute: usize, + pub GetStreamAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetStreamSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, penabled: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetStreamSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, enabled: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub ApplyStreamSelections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -11272,20 +11154,16 @@ pub struct IMFMediaError_Vtbl { ::windows_core::imp::com_interface!(IMFMediaEvent, IMFMediaEvent_Vtbl, 0xdf598932_f10c_4e39_bba2_c308f101daa3); ::windows_core::imp::interface_hierarchy!(IMFMediaEvent, ::windows_core::IUnknown, IMFAttributes); impl IMFMediaEvent { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -11337,10 +11215,8 @@ impl IMFMediaEvent { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -11385,9 +11261,7 @@ impl IMFMediaEvent { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -11408,9 +11282,7 @@ impl IMFMediaEvent { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStatus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -11422,10 +11294,7 @@ pub struct IMFMediaEvent_Vtbl { pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pmet: *mut u32) -> ::windows_core::HRESULT, pub GetExtendedType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidextendedtype: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phrstatus: *mut ::windows_core::HRESULT) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFMediaEventGenerator, IMFMediaEventGenerator_Vtbl, 0x2cd0bd52_bcd5_4b89_b62c_eadc0c031e7d); ::windows_core::imp::interface_hierarchy!(IMFMediaEventGenerator, ::windows_core::IUnknown); @@ -11448,10 +11317,8 @@ impl IMFMediaEventGenerator { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } } #[repr(C)] @@ -11461,10 +11328,7 @@ pub struct IMFMediaEventGenerator_Vtbl { pub GetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwflags: MEDIA_EVENT_GENERATOR_GET_EVENT_FLAGS, ppevent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub BeginGetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EndGetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppevent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub QueueEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - QueueEvent: usize, + pub QueueEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFMediaEventQueue, IMFMediaEventQueue_Vtbl, 0x36f846fc_2256_48b6_b58e_e2b638316581); ::windows_core::imp::interface_hierarchy!(IMFMediaEventQueue, ::windows_core::IUnknown); @@ -11493,10 +11357,8 @@ impl IMFMediaEventQueue { { (::windows_core::Interface::vtable(self).QueueEvent)(::windows_core::Interface::as_raw(self), pevent.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEventParamVar(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).QueueEventParamVar)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEventParamVar(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).QueueEventParamVar)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn QueueEventParamUnk(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, punk: P0) -> ::windows_core::Result<()> where @@ -11516,10 +11378,7 @@ pub struct IMFMediaEventQueue_Vtbl { pub BeginGetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EndGetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppevent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub QueueEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pevent: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub QueueEventParamVar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - QueueEventParamVar: usize, + pub QueueEventParamVar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub QueueEventParamUnk: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, punk: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Shutdown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -11803,10 +11662,8 @@ impl IMFMediaSession { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn SetTopology(&self, dwsettopologyflags: u32, ptopology: P0) -> ::windows_core::Result<()> where @@ -11817,10 +11674,8 @@ impl IMFMediaSession { pub unsafe fn ClearTopologies(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ClearTopologies)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Start(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Start)(::windows_core::Interface::as_raw(self), pguidtimeformat, pvarstartposition).ok() + pub unsafe fn Start(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Start)(::windows_core::Interface::as_raw(self), pguidtimeformat, ::core::mem::transmute(pvarstartposition)).ok() } pub unsafe fn Pause(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Pause)(::windows_core::Interface::as_raw(self)).ok() @@ -11853,10 +11708,7 @@ pub struct IMFMediaSession_Vtbl { pub base__: IMFMediaEventGenerator_Vtbl, pub SetTopology: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwsettopologyflags: u32, ptopology: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ClearTopologies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Start: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Start: usize, + pub Start: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Pause: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Stop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -12140,10 +11992,8 @@ impl IMFMediaSource { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetCharacteristics(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12153,13 +12003,11 @@ impl IMFMediaSource { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreatePresentationDescriptor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, pvarstartposition).ok() + (::windows_core::Interface::vtable(self).Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, ::core::mem::transmute(pvarstartposition)).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Stop)(::windows_core::Interface::as_raw(self)).ok() @@ -12177,10 +12025,7 @@ pub struct IMFMediaSource_Vtbl { pub base__: IMFMediaEventGenerator_Vtbl, pub GetCharacteristics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwcharacteristics: *mut u32) -> ::windows_core::HRESULT, pub CreatePresentationDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pppresentationdescriptor: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Start: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppresentationdescriptor: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Start: usize, + pub Start: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppresentationdescriptor: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Stop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Pause: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Shutdown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -12206,10 +12051,8 @@ impl IMFMediaSource2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetCharacteristics(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12219,13 +12062,11 @@ impl IMFMediaSource2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.CreatePresentationDescriptor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, pvarstartposition).ok() + (::windows_core::Interface::vtable(self).base__.base__.Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, ::core::mem::transmute(pvarstartposition)).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Stop)(::windows_core::Interface::as_raw(self)).ok() @@ -12284,10 +12125,8 @@ impl IMFMediaSourceEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetCharacteristics(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12297,13 +12136,11 @@ impl IMFMediaSourceEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CreatePresentationDescriptor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Start(&self, ppresentationdescriptor: P0, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, pvarstartposition).ok() + (::windows_core::Interface::vtable(self).base__.Start)(::windows_core::Interface::as_raw(self), ppresentationdescriptor.into_param().abi(), pguidtimeformat, ::core::mem::transmute(pvarstartposition)).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Stop)(::windows_core::Interface::as_raw(self)).ok() @@ -12489,10 +12326,8 @@ impl IMFMediaStream { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetMediaSource(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12538,10 +12373,8 @@ impl IMFMediaStream2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetMediaSource(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -12626,20 +12459,16 @@ pub struct IMFMediaTimeRange_Vtbl { ::windows_core::imp::com_interface!(IMFMediaType, IMFMediaType_Vtbl, 0x44ae0fa8_ea31_4109_8d2e_4cae4997c555); ::windows_core::imp::interface_hierarchy!(IMFMediaType, ::windows_core::IUnknown, IMFAttributes); impl IMFMediaType { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -12691,10 +12520,8 @@ impl IMFMediaType { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -12739,9 +12566,7 @@ impl IMFMediaType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -12838,23 +12663,17 @@ impl IMFMetadata { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetLanguage)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetAllLanguages(&self) -> ::windows_core::Result { + pub unsafe fn GetAllLanguages(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllLanguages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, pwszname: P0, ppvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, pwszname: P0, ppvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), ppvvalue).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), ::core::mem::transmute(ppvvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, pwszname: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, pwszname: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -12867,9 +12686,7 @@ impl IMFMetadata { { (::windows_core::Interface::vtable(self).DeleteProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetAllPropertyNames(&self) -> ::windows_core::Result { + pub unsafe fn GetAllPropertyNames(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllPropertyNames)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -12880,23 +12697,11 @@ pub struct IMFMetadata_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub SetLanguage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszrfc1766: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub GetLanguage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppwszrfc1766: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetAllLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppvlanguages: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetAllLanguages: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetProperty: usize, + pub GetAllLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppvlanguages: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, ppvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub DeleteProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetAllPropertyNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppvnames: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetAllPropertyNames: usize, + pub GetAllPropertyNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppvnames: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFMetadataProvider, IMFMetadataProvider_Vtbl, 0x56181d2d_e221_4adb_b1c8_3cee6a53f76f); ::windows_core::imp::interface_hierarchy!(IMFMetadataProvider, ::windows_core::IUnknown); @@ -13250,20 +13055,16 @@ pub struct IMFObjectReferenceStream_Vtbl { ::windows_core::imp::com_interface!(IMFOutputPolicy, IMFOutputPolicy_Vtbl, 0x7f00f10a_daed_41af_ab26_5fdfa4dfba3c); ::windows_core::imp::interface_hierarchy!(IMFOutputPolicy, ::windows_core::IUnknown, IMFAttributes); impl IMFOutputPolicy { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -13315,10 +13116,8 @@ impl IMFOutputPolicy { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -13363,9 +13162,7 @@ impl IMFOutputPolicy { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -13398,20 +13195,16 @@ pub struct IMFOutputPolicy_Vtbl { ::windows_core::imp::com_interface!(IMFOutputSchema, IMFOutputSchema_Vtbl, 0x7be0fc5b_abd9_44fb_a5c8_f50136e71599); ::windows_core::imp::interface_hierarchy!(IMFOutputSchema, ::windows_core::IUnknown, IMFAttributes); impl IMFOutputSchema { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -13463,10 +13256,8 @@ impl IMFOutputSchema { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -13511,9 +13302,7 @@ impl IMFOutputSchema { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -13703,14 +13492,10 @@ impl IMFPMediaItem { pub unsafe fn SetUserData(&self, dwuserdata: usize) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetUserData)(::windows_core::Interface::as_raw(self), dwuserdata).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetStartStopPosition(&self, pguidstartpositiontype: ::core::option::Option<*mut ::windows_core::GUID>, pvstartvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>, pguidstoppositiontype: ::core::option::Option<*mut ::windows_core::GUID>, pvstopvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetStartStopPosition(&self, pguidstartpositiontype: ::core::option::Option<*mut ::windows_core::GUID>, pvstartvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>, pguidstoppositiontype: ::core::option::Option<*mut ::windows_core::GUID>, pvstopvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetStartStopPosition)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pguidstartpositiontype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pvstartvalue.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pguidstoppositiontype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pvstopvalue.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetStartStopPosition(&self, pguidstartpositiontype: ::core::option::Option<*const ::windows_core::GUID>, pvstartvalue: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>, pguidstoppositiontype: ::core::option::Option<*const ::windows_core::GUID>, pvstopvalue: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn SetStartStopPosition(&self, pguidstartpositiontype: ::core::option::Option<*const ::windows_core::GUID>, pvstartvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>, pguidstoppositiontype: ::core::option::Option<*const ::windows_core::GUID>, pvstopvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetStartStopPosition)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pguidstartpositiontype.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pvstartvalue.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pguidstoppositiontype.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pvstopvalue.unwrap_or(::std::ptr::null()))).ok() } pub unsafe fn HasVideo(&self, pfhasvideo: ::core::option::Option<*mut super::super::Foundation::BOOL>, pfselected: ::core::option::Option<*mut super::super::Foundation::BOOL>) -> ::windows_core::Result<()> { @@ -13723,9 +13508,7 @@ impl IMFPMediaItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsProtected)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDuration)(::windows_core::Interface::as_raw(self), guidpositiontype, &mut result__).from_abi(result__) } @@ -13743,15 +13526,11 @@ impl IMFPMediaItem { { (::windows_core::Interface::vtable(self).SetStreamSelection)(::windows_core::Interface::as_raw(self), dwstreamindex, fenabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetStreamAttribute(&self, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStreamAttribute)(::windows_core::Interface::as_raw(self), dwstreamindex, guidmfattribute, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetPresentationAttribute(&self, guidmfattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPresentationAttribute)(::windows_core::Interface::as_raw(self), guidmfattribute, &mut result__).from_abi(result__) } @@ -13781,32 +13560,17 @@ pub struct IMFPMediaItem_Vtbl { pub GetObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppiunknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetUserData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwuserdata: *mut usize) -> ::windows_core::HRESULT, pub SetUserData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwuserdata: usize) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetStartStopPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetStartStopPosition: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetStartStopPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetStartStopPosition: usize, + pub GetStartStopPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *mut ::windows_core::GUID, pvstartvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pguidstoppositiontype: *mut ::windows_core::GUID, pvstopvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetStartStopPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidstartpositiontype: *const ::windows_core::GUID, pvstartvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pguidstoppositiontype: *const ::windows_core::GUID, pvstopvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub HasVideo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfhasvideo: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub HasAudio: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfhasaudio: *mut super::super::Foundation::BOOL, pfselected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub IsProtected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprotected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetDuration: usize, + pub GetDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetNumberOfStreams: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwstreamcount: *mut u32) -> ::windows_core::HRESULT, pub GetStreamSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, pfenabled: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetStreamSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, fenabled: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetStreamAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetStreamAttribute: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetPresentationAttribute: usize, + pub GetStreamAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidmfattribute: *const ::windows_core::GUID, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetCharacteristics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcharacteristics: *mut u32) -> ::windows_core::HRESULT, pub SetStreamSink: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, pmediasink: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -13829,20 +13593,14 @@ impl IMFPMediaPlayer { pub unsafe fn FrameStep(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).FrameStep)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetPosition(&self, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPosition)(::windows_core::Interface::as_raw(self), guidpositiontype, pvpositionvalue).ok() + pub unsafe fn SetPosition(&self, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetPosition)(::windows_core::Interface::as_raw(self), guidpositiontype, ::core::mem::transmute(pvpositionvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPosition(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetPosition(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPosition)(::windows_core::Interface::as_raw(self), guidpositiontype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetDuration(&self, guidpositiontype: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDuration)(::windows_core::Interface::as_raw(self), guidpositiontype, &mut result__).from_abi(result__) } @@ -13979,18 +13737,9 @@ pub struct IMFPMediaPlayer_Vtbl { pub Pause: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Stop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FrameStep: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetPosition: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetPosition: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetDuration: usize, + pub SetPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvpositionvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidpositiontype: *const ::windows_core::GUID, pvdurationvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub SetRate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flrate: f32) -> ::windows_core::HRESULT, pub GetRate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pflrate: *mut f32) -> ::windows_core::HRESULT, pub GetSupportedRates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fforwarddirection: super::super::Foundation::BOOL, pflslowestrate: *mut f32, pflfastestrate: *mut f32) -> ::windows_core::HRESULT, @@ -14198,20 +13947,16 @@ pub struct IMFPresentationClock_Vtbl { ::windows_core::imp::com_interface!(IMFPresentationDescriptor, IMFPresentationDescriptor_Vtbl, 0x03cb2711_24d7_4db6_a17f_f3a7a479a536); ::windows_core::imp::interface_hierarchy!(IMFPresentationDescriptor, ::windows_core::IUnknown, IMFAttributes); impl IMFPresentationDescriptor { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -14263,10 +14008,8 @@ impl IMFPresentationDescriptor { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -14311,9 +14054,7 @@ impl IMFPresentationDescriptor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -14770,9 +14511,7 @@ impl IMFSAMIStyle { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStyleCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetStyles(&self) -> ::windows_core::Result { + pub unsafe fn GetStyles(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStyles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -14792,10 +14531,7 @@ impl IMFSAMIStyle { pub struct IMFSAMIStyle_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetStyleCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetStyles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarstylearray: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetStyles: usize, + pub GetStyles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarstylearray: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub SetSelectedStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszstyle: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub GetSelectedStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppwszstyle: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, } @@ -14849,20 +14585,16 @@ pub struct IMFSSLCertificateManager_Vtbl { ::windows_core::imp::com_interface!(IMFSample, IMFSample_Vtbl, 0xc40a00f2_b93a_4d80_ae8c_5a1c634f58e4); ::windows_core::imp::interface_hierarchy!(IMFSample, ::windows_core::IUnknown, IMFAttributes); impl IMFSample { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -14914,10 +14646,8 @@ impl IMFSample { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -14962,9 +14692,7 @@ impl IMFSample { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -15316,20 +15044,15 @@ pub struct IMFSecureChannel_Vtbl { ::windows_core::imp::com_interface!(IMFSeekInfo, IMFSeekInfo_Vtbl, 0x26afea53_d9ed_42b5_ab80_e64f9ee34779); ::windows_core::imp::interface_hierarchy!(IMFSeekInfo, ::windows_core::IUnknown); impl IMFSeekInfo { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetNearestKeyFrames(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarpreviouskeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarnextkeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetNearestKeyFrames)(::windows_core::Interface::as_raw(self), pguidtimeformat, pvarstartposition, pvarpreviouskeyframe, pvarnextkeyframe).ok() + pub unsafe fn GetNearestKeyFrames(&self, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::windows_core::PROPVARIANT, pvarpreviouskeyframe: *mut ::windows_core::PROPVARIANT, pvarnextkeyframe: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetNearestKeyFrames)(::windows_core::Interface::as_raw(self), pguidtimeformat, ::core::mem::transmute(pvarstartposition), ::core::mem::transmute(pvarpreviouskeyframe), ::core::mem::transmute(pvarnextkeyframe)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IMFSeekInfo_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetNearestKeyFrames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarpreviouskeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, pvarnextkeyframe: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetNearestKeyFrames: usize, + pub GetNearestKeyFrames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidtimeformat: *const ::windows_core::GUID, pvarstartposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarpreviouskeyframe: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarnextkeyframe: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFSensorActivitiesReport, IMFSensorActivitiesReport_Vtbl, 0x683f7a5e_4a19_43cd_b1a9_dbf4ab3f7777); ::windows_core::imp::interface_hierarchy!(IMFSensorActivitiesReport, ::windows_core::IUnknown); @@ -15622,20 +15345,16 @@ pub struct IMFSensorProfileCollection_Vtbl { ::windows_core::imp::com_interface!(IMFSensorStream, IMFSensorStream_Vtbl, 0xe9a42171_c56e_498a_8b39_eda5a070b7fc); ::windows_core::imp::interface_hierarchy!(IMFSensorStream, ::windows_core::IUnknown, IMFAttributes); impl IMFSensorStream { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -15687,10 +15406,8 @@ impl IMFSensorStream { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -15735,9 +15452,7 @@ impl IMFSensorStream { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -16278,10 +15993,8 @@ impl IMFSourceReader { { (::windows_core::Interface::vtable(self).SetCurrentMediaType)(::windows_core::Interface::as_raw(self), dwstreamindex, ::core::mem::transmute(pdwreserved.unwrap_or(::std::ptr::null())), pmediatype.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCurrentPosition)(::windows_core::Interface::as_raw(self), guidtimeformat, varposition).ok() + pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetCurrentPosition)(::windows_core::Interface::as_raw(self), guidtimeformat, ::core::mem::transmute(varposition)).ok() } pub unsafe fn ReadSample(&self, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: ::core::option::Option<*mut u32>, pdwstreamflags: ::core::option::Option<*mut u32>, plltimestamp: ::core::option::Option<*mut i64>, ppsample: ::core::option::Option<*mut ::core::option::Option>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ReadSample)(::windows_core::Interface::as_raw(self), dwstreamindex, dwcontrolflags, ::core::mem::transmute(pdwactualstreamindex.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pdwstreamflags.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plltimestamp.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppsample.unwrap_or(::std::ptr::null_mut()))).ok() @@ -16292,9 +16005,7 @@ impl IMFSourceReader { pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetServiceForStream)(::windows_core::Interface::as_raw(self), dwstreamindex, guidservice, riid, ppvobject).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPresentationAttribute)(::windows_core::Interface::as_raw(self), dwstreamindex, guidattribute, &mut result__).from_abi(result__) } @@ -16308,17 +16019,11 @@ pub struct IMFSourceReader_Vtbl { pub GetNativeMediaType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, dwmediatypeindex: u32, ppmediatype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetCurrentMediaType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, ppmediatype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetCurrentMediaType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, pdwreserved: *const u32, pmediatype: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetCurrentPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidtimeformat: *const ::windows_core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetCurrentPosition: usize, + pub SetCurrentPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guidtimeformat: *const ::windows_core::GUID, varposition: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub ReadSample: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: *mut u32, pdwstreamflags: *mut u32, plltimestamp: *mut i64, ppsample: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Flush: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32) -> ::windows_core::HRESULT, pub GetServiceForStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidservice: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID, pvarattribute: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetPresentationAttribute: usize, + pub GetPresentationAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID, pvarattribute: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFSourceReaderCallback, IMFSourceReaderCallback_Vtbl, 0xdeec8d99_fa1d_4d82_84c2_2c8969944867); ::windows_core::imp::interface_hierarchy!(IMFSourceReaderCallback, ::windows_core::IUnknown); @@ -16406,10 +16111,8 @@ impl IMFSourceReaderEx { { (::windows_core::Interface::vtable(self).base__.SetCurrentMediaType)(::windows_core::Interface::as_raw(self), dwstreamindex, ::core::mem::transmute(pdwreserved.unwrap_or(::std::ptr::null())), pmediatype.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetCurrentPosition)(::windows_core::Interface::as_raw(self), guidtimeformat, varposition).ok() + pub unsafe fn SetCurrentPosition(&self, guidtimeformat: *const ::windows_core::GUID, varposition: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetCurrentPosition)(::windows_core::Interface::as_raw(self), guidtimeformat, ::core::mem::transmute(varposition)).ok() } pub unsafe fn ReadSample(&self, dwstreamindex: u32, dwcontrolflags: u32, pdwactualstreamindex: ::core::option::Option<*mut u32>, pdwstreamflags: ::core::option::Option<*mut u32>, plltimestamp: ::core::option::Option<*mut i64>, ppsample: ::core::option::Option<*mut ::core::option::Option>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ReadSample)(::windows_core::Interface::as_raw(self), dwstreamindex, dwcontrolflags, ::core::mem::transmute(pdwactualstreamindex.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pdwstreamflags.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plltimestamp.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppsample.unwrap_or(::std::ptr::null_mut()))).ok() @@ -16420,9 +16123,7 @@ impl IMFSourceReaderEx { pub unsafe fn GetServiceForStream(&self, dwstreamindex: u32, guidservice: *const ::windows_core::GUID, riid: *const ::windows_core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetServiceForStream)(::windows_core::Interface::as_raw(self), dwstreamindex, guidservice, riid, ppvobject).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetPresentationAttribute(&self, dwstreamindex: u32, guidattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPresentationAttribute)(::windows_core::Interface::as_raw(self), dwstreamindex, guidattribute, &mut result__).from_abi(result__) } @@ -16610,20 +16311,16 @@ pub struct IMFSpatialAudioObjectBuffer_Vtbl { ::windows_core::imp::com_interface!(IMFSpatialAudioSample, IMFSpatialAudioSample_Vtbl, 0xabf28a9b_3393_4290_ba79_5ffc46d986b2); ::windows_core::imp::interface_hierarchy!(IMFSpatialAudioSample, ::windows_core::IUnknown, IMFAttributes, IMFSample); impl IMFSpatialAudioSample { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -16675,10 +16372,8 @@ impl IMFSpatialAudioSample { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -16723,9 +16418,7 @@ impl IMFSpatialAudioSample { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -16815,20 +16508,16 @@ pub struct IMFSpatialAudioSample_Vtbl { ::windows_core::imp::com_interface!(IMFStreamDescriptor, IMFStreamDescriptor_Vtbl, 0x56c03d9c_9dbb_45f5_ab4b_d80f47c05938); ::windows_core::imp::interface_hierarchy!(IMFStreamDescriptor, ::windows_core::IUnknown, IMFAttributes); impl IMFStreamDescriptor { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -16880,10 +16569,8 @@ impl IMFStreamDescriptor { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -16928,9 +16615,7 @@ impl IMFStreamDescriptor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -16976,10 +16661,8 @@ impl IMFStreamSink { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EndGetEvent)(::windows_core::Interface::as_raw(self), presult.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, pvvalue).ok() + pub unsafe fn QueueEvent(&self, met: u32, guidextendedtype: *const ::windows_core::GUID, hrstatus: ::windows_core::HRESULT, pvvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.QueueEvent)(::windows_core::Interface::as_raw(self), met, guidextendedtype, hrstatus, ::core::mem::transmute(pvvalue)).ok() } pub unsafe fn GetMediaSink(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -16999,10 +16682,8 @@ impl IMFStreamSink { { (::windows_core::Interface::vtable(self).ProcessSample)(::windows_core::Interface::as_raw(self), psample.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn PlaceMarker(&self, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarcontextvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PlaceMarker)(::windows_core::Interface::as_raw(self), emarkertype, pvarmarkervalue, pvarcontextvalue).ok() + pub unsafe fn PlaceMarker(&self, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const ::windows_core::PROPVARIANT, pvarcontextvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PlaceMarker)(::windows_core::Interface::as_raw(self), emarkertype, ::core::mem::transmute(pvarmarkervalue), ::core::mem::transmute(pvarcontextvalue)).ok() } pub unsafe fn Flush(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Flush)(::windows_core::Interface::as_raw(self)).ok() @@ -17016,10 +16697,7 @@ pub struct IMFStreamSink_Vtbl { pub GetIdentifier: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwidentifier: *mut u32) -> ::windows_core::HRESULT, pub GetMediaTypeHandler: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pphandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ProcessSample: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psample: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub PlaceMarker: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pvarcontextvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - PlaceMarker: usize, + pub PlaceMarker: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, emarkertype: MFSTREAMSINK_MARKER_TYPE, pvarmarkervalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pvarcontextvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Flush: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFStreamingSinkConfig, IMFStreamingSinkConfig_Vtbl, 0x9db7aa41_3cc5_40d4_8509_555804ad34cc); @@ -17058,14 +16736,12 @@ pub struct IMFSystemId_Vtbl { ::windows_core::imp::com_interface!(IMFTimecodeTranslate, IMFTimecodeTranslate_Vtbl, 0xab9d8661_f7e8_4ef4_9861_89f334f94e74); ::windows_core::imp::interface_hierarchy!(IMFTimecodeTranslate, ::windows_core::IUnknown); impl IMFTimecodeTranslate { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn BeginConvertTimecodeToHNS(&self, ppropvartimecode: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pcallback: P0, punkstate: P1) -> ::windows_core::Result<()> + pub unsafe fn BeginConvertTimecodeToHNS(&self, ppropvartimecode: *const ::windows_core::PROPVARIANT, pcallback: P0, punkstate: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, { - (::windows_core::Interface::vtable(self).BeginConvertTimecodeToHNS)(::windows_core::Interface::as_raw(self), ppropvartimecode, pcallback.into_param().abi(), punkstate.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).BeginConvertTimecodeToHNS)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvartimecode), pcallback.into_param().abi(), punkstate.into_param().abi()).ok() } pub unsafe fn EndConvertTimecodeToHNS(&self, presult: P0) -> ::windows_core::Result where @@ -17081,9 +16757,7 @@ impl IMFTimecodeTranslate { { (::windows_core::Interface::vtable(self).BeginConvertHNSToTimecode)(::windows_core::Interface::as_raw(self), hnstime, pcallback.into_param().abi(), punkstate.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn EndConvertHNSToTimecode(&self, presult: P0) -> ::windows_core::Result + pub unsafe fn EndConvertHNSToTimecode(&self, presult: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, { @@ -17095,16 +16769,10 @@ impl IMFTimecodeTranslate { #[doc(hidden)] pub struct IMFTimecodeTranslate_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub BeginConvertTimecodeToHNS: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvartimecode: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - BeginConvertTimecodeToHNS: usize, + pub BeginConvertTimecodeToHNS: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvartimecode: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EndConvertTimecodeToHNS: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, phnstime: *mut i64) -> ::windows_core::HRESULT, pub BeginConvertHNSToTimecode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hnstime: i64, pcallback: *mut ::core::ffi::c_void, punkstate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub EndConvertHNSToTimecode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppropvartimecode: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - EndConvertHNSToTimecode: usize, + pub EndConvertHNSToTimecode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presult: *mut ::core::ffi::c_void, ppropvartimecode: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMFTimedText, IMFTimedText_Vtbl, 0x1f2a94c9_a3df_430d_9d0f_acd85ddc29af); ::windows_core::imp::interface_hierarchy!(IMFTimedText, ::windows_core::IUnknown); @@ -17747,20 +17415,16 @@ pub struct IMFTopoLoader_Vtbl { ::windows_core::imp::com_interface!(IMFTopology, IMFTopology_Vtbl, 0x83cf873a_f6da_4bc8_823f_bacfd55dc433); ::windows_core::imp::interface_hierarchy!(IMFTopology, ::windows_core::IUnknown, IMFAttributes); impl IMFTopology { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -17812,10 +17476,8 @@ impl IMFTopology { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -17860,9 +17522,7 @@ impl IMFTopology { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -17935,20 +17595,16 @@ pub struct IMFTopology_Vtbl { ::windows_core::imp::com_interface!(IMFTopologyNode, IMFTopologyNode_Vtbl, 0x83cf873a_f6da_4bc8_823f_bacfd55dc430); ::windows_core::imp::interface_hierarchy!(IMFTopologyNode, ::windows_core::IUnknown, IMFAttributes); impl IMFTopologyNode { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -18000,10 +17656,8 @@ impl IMFTopologyNode { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -18048,9 +17702,7 @@ impl IMFTopologyNode { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -18600,20 +18252,16 @@ pub struct IMFVideoDisplayControl_Vtbl { ::windows_core::imp::com_interface!(IMFVideoMediaType, IMFVideoMediaType_Vtbl, 0xb99f381f_a8f9_47a2_a5af_ca3a225a3890); ::windows_core::imp::interface_hierarchy!(IMFVideoMediaType, ::windows_core::IUnknown, IMFAttributes, IMFMediaType); impl IMFVideoMediaType { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -18665,10 +18313,8 @@ impl IMFVideoMediaType { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -18713,9 +18359,7 @@ impl IMFVideoMediaType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> @@ -19261,20 +18905,16 @@ pub struct IMFVideoSampleAllocatorNotifyEx_Vtbl { ::windows_core::imp::com_interface!(IMFVirtualCamera, IMFVirtualCamera_Vtbl, 0x1c08a864_ef6c_4c75_af59_5f2d68da9563); ::windows_core::imp::interface_hierarchy!(IMFVirtualCamera, ::windows_core::IUnknown, IMFAttributes); impl IMFVirtualCamera { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItem(&self, guidkey: *const ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetItemType(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetItemType)(::windows_core::Interface::as_raw(self), guidkey, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn CompareItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, value, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CompareItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value), &mut result__).from_abi(result__) } pub unsafe fn Compare(&self, ptheirs: P0, matchtype: MF_ATTRIBUTES_MATCH_TYPE) -> ::windows_core::Result where @@ -19326,10 +18966,8 @@ impl IMFVirtualCamera { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetUnknown)(::windows_core::Interface::as_raw(self), guidkey, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, value).ok() + pub unsafe fn SetItem(&self, guidkey: *const ::windows_core::GUID, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetItem)(::windows_core::Interface::as_raw(self), guidkey, ::core::mem::transmute(value)).ok() } pub unsafe fn DeleteItem(&self, guidkey: *const ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DeleteItem)(::windows_core::Interface::as_raw(self), guidkey).ok() @@ -19374,9 +19012,7 @@ impl IMFVirtualCamera { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetItemByIndex(&self, unindex: u32, pguidkey: *mut ::windows_core::GUID, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetItemByIndex)(::windows_core::Interface::as_raw(self), unindex, pguidkey, ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn CopyAllItems(&self, pdest: P0) -> ::windows_core::Result<()> diff --git a/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/impl.rs index 3cd19b14f1..2af3e0c4ad 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeed_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Xml(&self, count: i32, sortproperty: FEEDS_XML_SORT_PROPERTY, sortorder: FEEDS_XML_SORT_ORDER, filterflags: FEEDS_XML_FILTER_FLAGS, includeflags: FEEDS_XML_INCLUDE_FLAGS) -> ::windows_core::Result<::windows_core::BSTR>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -46,9 +46,9 @@ pub trait IFeed_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UnreadItemCount(&self) -> ::windows_core::Result; fn ItemCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeed {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeed_Vtbl { pub const fn new, Impl: IFeed_Impl, const OFFSET: isize>() -> IFeed_Vtbl { unsafe extern "system" fn Xml, Impl: IFeed_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: i32, sortproperty: FEEDS_XML_SORT_PROPERTY, sortorder: FEEDS_XML_SORT_ORDER, filterflags: FEEDS_XML_FILTER_FLAGS, includeflags: FEEDS_XML_INCLUDE_FLAGS, xml: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -509,8 +509,8 @@ impl IFeed_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeed2_Impl: Sized + IFeed_Impl { fn GetItemByEffectiveId(&self, itemeffectiveid: i32) -> ::windows_core::Result; fn LastItemDownloadTime(&self) -> ::windows_core::Result; @@ -519,9 +519,9 @@ pub trait IFeed2_Impl: Sized + IFeed_Impl { fn SetCredentials(&self, username: &::windows_core::BSTR, password: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ClearCredentials(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeed2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeed2_Vtbl { pub const fn new, Impl: IFeed2_Impl, const OFFSET: isize>() -> IFeed2_Vtbl { unsafe extern "system" fn GetItemByEffectiveId, Impl: IFeed2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemeffectiveid: i32, disp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -592,8 +592,8 @@ impl IFeed2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedEnclosure_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Url(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Type(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -609,9 +609,9 @@ pub trait IFeedEnclosure_Impl: Sized + super::super::System::Com::IDispatch_Impl fn RemoveFile(&self) -> ::windows_core::Result<()>; fn SetFile(&self, downloadurl: &::windows_core::BSTR, downloadfilepath: &::windows_core::BSTR, downloadmimetype: &::windows_core::BSTR, enclosurefilename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedEnclosure {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedEnclosure_Vtbl { pub const fn new, Impl: IFeedEnclosure_Impl, const OFFSET: isize>() -> IFeedEnclosure_Vtbl { unsafe extern "system" fn Url, Impl: IFeedEnclosure_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, enclosureurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -754,8 +754,8 @@ impl IFeedEnclosure_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Error(&self) -> ::windows_core::Result<()>; fn FeedDeleted(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -766,9 +766,9 @@ pub trait IFeedEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FeedDownloadCompleted(&self, path: &::windows_core::BSTR, error: FEEDS_DOWNLOAD_ERROR) -> ::windows_core::Result<()>; fn FeedItemCountChanged(&self, path: &::windows_core::BSTR, itemcounttype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedEvents_Vtbl { pub const fn new, Impl: IFeedEvents_Impl, const OFFSET: isize>() -> IFeedEvents_Vtbl { unsafe extern "system" fn Error, Impl: IFeedEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -827,8 +827,8 @@ impl IFeedEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedFolder_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Feeds(&self) -> ::windows_core::Result; fn Subfolders(&self) -> ::windows_core::Result; @@ -849,9 +849,9 @@ pub trait IFeedFolder_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TotalItemCount(&self) -> ::windows_core::Result; fn GetWatcher(&self, scope: FEEDS_EVENTS_SCOPE, mask: FEEDS_EVENTS_MASK) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedFolder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedFolder_Vtbl { pub const fn new, Impl: IFeedFolder_Impl, const OFFSET: isize>() -> IFeedFolder_Vtbl { unsafe extern "system" fn Feeds, Impl: IFeedFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, disp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1060,8 +1060,8 @@ impl IFeedFolder_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedFolderEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Error(&self) -> ::windows_core::Result<()>; fn FolderAdded(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1080,9 +1080,9 @@ pub trait IFeedFolderEvents_Impl: Sized + super::super::System::Com::IDispatch_I fn FeedDownloadCompleted(&self, path: &::windows_core::BSTR, error: FEEDS_DOWNLOAD_ERROR) -> ::windows_core::Result<()>; fn FeedItemCountChanged(&self, path: &::windows_core::BSTR, itemcounttype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedFolderEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedFolderEvents_Vtbl { pub const fn new, Impl: IFeedFolderEvents_Impl, const OFFSET: isize>() -> IFeedFolderEvents_Vtbl { unsafe extern "system" fn Error, Impl: IFeedFolderEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1189,8 +1189,8 @@ impl IFeedFolderEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Xml(&self, includeflags: FEEDS_XML_INCLUDE_FLAGS) -> ::windows_core::Result<::windows_core::BSTR>; fn Title(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1210,9 +1210,9 @@ pub trait IFeedItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LastDownloadTime(&self) -> ::windows_core::Result; fn Modified(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedItem_Vtbl { pub const fn new, Impl: IFeedItem_Impl, const OFFSET: isize>() -> IFeedItem_Vtbl { unsafe extern "system" fn Xml, Impl: IFeedItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, includeflags: FEEDS_XML_INCLUDE_FLAGS, xml: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1415,14 +1415,14 @@ impl IFeedItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedItem2_Impl: Sized + IFeedItem_Impl { fn EffectiveId(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedItem2_Vtbl { pub const fn new, Impl: IFeedItem2_Impl, const OFFSET: isize>() -> IFeedItem2_Vtbl { unsafe extern "system" fn EffectiveId, Impl: IFeedItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, effectiveid: *mut i32) -> ::windows_core::HRESULT { @@ -1442,16 +1442,16 @@ impl IFeedItem2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IFeedsEnum_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IFeedsEnum {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IFeedsEnum_Vtbl { pub const fn new, Impl: IFeedsEnum_Impl, const OFFSET: isize>() -> IFeedsEnum_Vtbl { unsafe extern "system" fn Count, Impl: IFeedsEnum_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -1498,8 +1498,8 @@ impl IFeedsEnum_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFeedsManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RootFolder(&self) -> ::windows_core::Result; fn IsSubscribed(&self, feedurl: &::windows_core::BSTR) -> ::windows_core::Result; @@ -1518,9 +1518,9 @@ pub trait IFeedsManager_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Normalize(&self, feedxmlin: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn ItemCountLimit(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFeedsManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFeedsManager_Vtbl { pub const fn new, Impl: IFeedsManager_Impl, const OFFSET: isize>() -> IFeedsManager_Vtbl { unsafe extern "system" fn RootFolder, Impl: IFeedsManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, disp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1720,16 +1720,16 @@ impl IWMPAudioRenderConfig_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPCdrom_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn driveSpecifier(&self, pbstrdrive: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn playlist(&self) -> ::windows_core::Result; fn eject(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPCdrom {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPCdrom_Vtbl { pub const fn new, Impl: IWMPCdrom_Impl, const OFFSET: isize>() -> IWMPCdrom_Vtbl { unsafe extern "system" fn driveSpecifier, Impl: IWMPCdrom_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrdrive: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1885,16 +1885,16 @@ impl IWMPCdromBurn_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPCdromCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn item(&self, lindex: i32) -> ::windows_core::Result; fn getByDriveSpecifier(&self, bstrdrivespecifier: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPCdromCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPCdromCollection_Vtbl { pub const fn new, Impl: IWMPCdromCollection_Impl, const OFFSET: isize>() -> IWMPCdromCollection_Vtbl { unsafe extern "system" fn count, Impl: IWMPCdromCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1976,8 +1976,8 @@ impl IWMPCdromRip_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPClosedCaption_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SAMIStyle(&self, pbstrsamistyle: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSAMIStyle(&self, bstrsamistyle: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1988,9 +1988,9 @@ pub trait IWMPClosedCaption_Impl: Sized + super::super::System::Com::IDispatch_I fn captioningId(&self, pbstrcaptioningid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetcaptioningId(&self, bstrcaptioningid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPClosedCaption {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPClosedCaption_Vtbl { pub const fn new, Impl: IWMPClosedCaption_Impl, const OFFSET: isize>() -> IWMPClosedCaption_Vtbl { unsafe extern "system" fn SAMIStyle, Impl: IWMPClosedCaption_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsamistyle: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2049,8 +2049,8 @@ impl IWMPClosedCaption_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPClosedCaption2_Impl: Sized + IWMPClosedCaption_Impl { fn SAMILangCount(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn getSAMILangName(&self, nindex: i32, pbstrname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2058,9 +2058,9 @@ pub trait IWMPClosedCaption2_Impl: Sized + IWMPClosedCaption_Impl { fn SAMIStyleCount(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn getSAMIStyleName(&self, nindex: i32, pbstrname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPClosedCaption2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPClosedCaption2_Vtbl { pub const fn new, Impl: IWMPClosedCaption2_Impl, const OFFSET: isize>() -> IWMPClosedCaption2_Vtbl { unsafe extern "system" fn SAMILangCount, Impl: IWMPClosedCaption2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2244,36 +2244,36 @@ impl IWMPContentContainerList_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPContentPartner_Impl: Sized { fn SetCallback(&self, pcallback: ::core::option::Option<&IWMPContentPartnerCallback>) -> ::windows_core::Result<()>; - fn Notify(&self, r#type: WMPPartnerNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetItemInfo(&self, bstrinfoname: &::windows_core::BSTR, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn GetContentPartnerInfo(&self, bstrinfoname: &::windows_core::BSTR) -> ::windows_core::Result; - fn GetCommands(&self, location: &::windows_core::BSTR, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: &::windows_core::BSTR, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::Result<()>; - fn InvokeCommand(&self, dwcommandid: u32, location: &::windows_core::BSTR, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: &::windows_core::BSTR, citemids: u32, rgitemids: *const u32) -> ::windows_core::Result<()>; + fn Notify(&self, r#type: WMPPartnerNotification, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetItemInfo(&self, bstrinfoname: &::windows_core::BSTR, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetContentPartnerInfo(&self, bstrinfoname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetCommands(&self, location: &::windows_core::BSTR, plocationcontext: *const ::windows_core::VARIANT, itemlocation: &::windows_core::BSTR, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::Result<()>; + fn InvokeCommand(&self, dwcommandid: u32, location: &::windows_core::BSTR, plocationcontext: *const ::windows_core::VARIANT, itemlocation: &::windows_core::BSTR, citemids: u32, rgitemids: *const u32) -> ::windows_core::Result<()>; fn CanBuySilent(&self, pinfo: ::core::option::Option<&IWMPContentContainerList>, pbstrtotalprice: *mut ::windows_core::BSTR, psilentok: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Buy(&self, pinfo: ::core::option::Option<&IWMPContentContainerList>, cookie: u32) -> ::windows_core::Result<()>; - fn GetStreamingURL(&self, st: WMPStreamingType, pstreamcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn GetStreamingURL(&self, st: WMPStreamingType, pstreamcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; fn Download(&self, pinfo: ::core::option::Option<&IWMPContentContainerList>, cookie: u32) -> ::windows_core::Result<()>; fn DownloadTrackComplete(&self, hrresult: ::windows_core::HRESULT, contentid: u32, downloadtrackparam: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn RefreshLicense(&self, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: &::windows_core::BSTR, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: &::windows_core::BSTR, preasoncontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetCatalogURL(&self, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::windows_core::BSTR, pexpirationdate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetTemplate(&self, task: WMPTaskType, location: &::windows_core::BSTR, pcontext: *const super::super::System::Variant::VARIANT, clicklocation: &::windows_core::BSTR, pclickcontext: *const super::super::System::Variant::VARIANT, bstrfilter: &::windows_core::BSTR, bstrviewparams: &::windows_core::BSTR, pbstrtemplateurl: *mut ::windows_core::BSTR, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::Result<()>; + fn RefreshLicense(&self, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: &::windows_core::BSTR, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: &::windows_core::BSTR, preasoncontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetCatalogURL(&self, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::windows_core::BSTR, pexpirationdate: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetTemplate(&self, task: WMPTaskType, location: &::windows_core::BSTR, pcontext: *const ::windows_core::VARIANT, clicklocation: &::windows_core::BSTR, pclickcontext: *const ::windows_core::VARIANT, bstrfilter: &::windows_core::BSTR, bstrviewparams: &::windows_core::BSTR, pbstrtemplateurl: *mut ::windows_core::BSTR, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::Result<()>; fn UpdateDevice(&self, bstrdevicename: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetListContents(&self, location: &::windows_core::BSTR, pcontext: *const super::super::System::Variant::VARIANT, bstrlisttype: &::windows_core::BSTR, bstrparams: &::windows_core::BSTR, dwlistcookie: u32) -> ::windows_core::Result<()>; + fn GetListContents(&self, location: &::windows_core::BSTR, pcontext: *const ::windows_core::VARIANT, bstrlisttype: &::windows_core::BSTR, bstrparams: &::windows_core::BSTR, dwlistcookie: u32) -> ::windows_core::Result<()>; fn Login(&self, userinfo: &super::super::System::Com::BLOB, pwdinfo: &super::super::System::Com::BLOB, fusedcachedcreds: super::super::Foundation::VARIANT_BOOL, foktocache: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Authenticate(&self, userinfo: &super::super::System::Com::BLOB, pwdinfo: &super::super::System::Com::BLOB) -> ::windows_core::Result<()>; fn Logout(&self) -> ::windows_core::Result<()>; fn SendMessage(&self, bstrmsg: &::windows_core::BSTR, bstrparam: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn StationEvent(&self, bstrstationeventtype: &::windows_core::BSTR, stationid: u32, playlistindex: u32, trackid: u32, trackdata: &::windows_core::BSTR, dwsecondsplayed: u32) -> ::windows_core::Result<()>; fn CompareContainerListPrices(&self, plistbase: ::core::option::Option<&IWMPContentContainerList>, plistcompare: ::core::option::Option<&IWMPContentContainerList>) -> ::windows_core::Result; - fn VerifyPermission(&self, bstrpermission: &::windows_core::BSTR, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn VerifyPermission(&self, bstrpermission: &::windows_core::BSTR, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPContentPartner {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPContentPartner_Vtbl { pub const fn new, Impl: IWMPContentPartner_Impl, const OFFSET: isize>() -> IWMPContentPartner_Vtbl { unsafe extern "system" fn SetCallback, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2281,12 +2281,12 @@ impl IWMPContentPartner_Vtbl { let this = (*this).get_impl(); this.SetCallback(::windows_core::from_raw_borrowed(&pcallback)).into() } - unsafe extern "system" fn Notify, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: WMPPartnerNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Notify, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: WMPPartnerNotification, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Notify(::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&pcontext)).into() } - unsafe extern "system" fn GetItemInfo, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetItemInfo, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetItemInfo(::core::mem::transmute(&bstrinfoname), ::core::mem::transmute_copy(&pcontext)) { @@ -2297,7 +2297,7 @@ impl IWMPContentPartner_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetContentPartnerInfo, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetContentPartnerInfo, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetContentPartnerInfo(::core::mem::transmute(&bstrinfoname)) { @@ -2308,12 +2308,12 @@ impl IWMPContentPartner_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCommands, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCommands, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetCommands(::core::mem::transmute(&location), ::core::mem::transmute_copy(&plocationcontext), ::core::mem::transmute(&itemlocation), ::core::mem::transmute_copy(&citemids), ::core::mem::transmute_copy(&prgitemids), ::core::mem::transmute_copy(&pcitemids), ::core::mem::transmute_copy(&pprgitems)).into() } - unsafe extern "system" fn InvokeCommand, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcommandid: u32, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, rgitemids: *const u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeCommand, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcommandid: u32, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, rgitemids: *const u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeCommand(::core::mem::transmute_copy(&dwcommandid), ::core::mem::transmute(&location), ::core::mem::transmute_copy(&plocationcontext), ::core::mem::transmute(&itemlocation), ::core::mem::transmute_copy(&citemids), ::core::mem::transmute_copy(&rgitemids)).into() @@ -2328,7 +2328,7 @@ impl IWMPContentPartner_Vtbl { let this = (*this).get_impl(); this.Buy(::windows_core::from_raw_borrowed(&pinfo), ::core::mem::transmute_copy(&cookie)).into() } - unsafe extern "system" fn GetStreamingURL, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, st: WMPStreamingType, pstreamcontext: *const super::super::System::Variant::VARIANT, pbstrurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStreamingURL, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, st: WMPStreamingType, pstreamcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStreamingURL(::core::mem::transmute_copy(&st), ::core::mem::transmute_copy(&pstreamcontext)) { @@ -2349,17 +2349,17 @@ impl IWMPContentPartner_Vtbl { let this = (*this).get_impl(); this.DownloadTrackComplete(::core::mem::transmute_copy(&hrresult), ::core::mem::transmute_copy(&contentid), ::core::mem::transmute(&downloadtrackparam)).into() } - unsafe extern "system" fn RefreshLicense, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: ::std::mem::MaybeUninit<::windows_core::BSTR>, preasoncontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RefreshLicense, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: ::std::mem::MaybeUninit<::windows_core::BSTR>, preasoncontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RefreshLicense(::core::mem::transmute_copy(&dwcookie), ::core::mem::transmute_copy(&flocal), ::core::mem::transmute(&bstrurl), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&contentid), ::core::mem::transmute(&bstrrefreshreason), ::core::mem::transmute_copy(&preasoncontext)).into() } - unsafe extern "system" fn GetCatalogURL, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexpirationdate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCatalogURL, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexpirationdate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetCatalogURL(::core::mem::transmute_copy(&dwcatalogversion), ::core::mem::transmute_copy(&dwcatalogschemaversion), ::core::mem::transmute_copy(&cataloglcid), ::core::mem::transmute_copy(&pdwnewcatalogversion), ::core::mem::transmute_copy(&pbstrcatalogurl), ::core::mem::transmute_copy(&pexpirationdate)).into() } - unsafe extern "system" fn GetTemplate, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, task: WMPTaskType, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, clicklocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, pclickcontext: *const super::super::System::Variant::VARIANT, bstrfilter: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrviewparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrtemplateurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetTemplate, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, task: WMPTaskType, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, clicklocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, pclickcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrfilter: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrviewparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrtemplateurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetTemplate(::core::mem::transmute_copy(&task), ::core::mem::transmute(&location), ::core::mem::transmute_copy(&pcontext), ::core::mem::transmute(&clicklocation), ::core::mem::transmute_copy(&pclickcontext), ::core::mem::transmute(&bstrfilter), ::core::mem::transmute(&bstrviewparams), ::core::mem::transmute_copy(&pbstrtemplateurl), ::core::mem::transmute_copy(&ptemplatesize)).into() @@ -2369,7 +2369,7 @@ impl IWMPContentPartner_Vtbl { let this = (*this).get_impl(); this.UpdateDevice(::core::mem::transmute(&bstrdevicename)).into() } - unsafe extern "system" fn GetListContents, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, bstrlisttype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwlistcookie: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetListContents, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrlisttype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwlistcookie: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetListContents(::core::mem::transmute(&location), ::core::mem::transmute_copy(&pcontext), ::core::mem::transmute(&bstrlisttype), ::core::mem::transmute(&bstrparams), ::core::mem::transmute_copy(&dwlistcookie)).into() @@ -2410,7 +2410,7 @@ impl IWMPContentPartner_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn VerifyPermission, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn VerifyPermission, Impl: IWMPContentPartner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.VerifyPermission(::core::mem::transmute(&bstrpermission), ::core::mem::transmute_copy(&pcontext)).into() @@ -2446,10 +2446,8 @@ impl IWMPContentPartner_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IWMPContentPartnerCallback_Impl: Sized { - fn Notify(&self, r#type: WMPCallbackNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Notify(&self, r#type: WMPCallbackNotification, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BuyComplete(&self, hrresult: ::windows_core::HRESULT, dwbuycookie: u32) -> ::windows_core::Result<()>; fn DownloadTrack(&self, cookie: u32, bstrtrackurl: &::windows_core::BSTR, dwservicetrackid: u32, bstrdownloadparams: &::windows_core::BSTR, hrdownload: ::windows_core::HRESULT) -> ::windows_core::Result<()>; fn GetCatalogVersion(&self, pdwversion: *mut u32, pdwschemaversion: *mut u32, plcid: *mut u32) -> ::windows_core::Result<()>; @@ -2461,14 +2459,12 @@ pub trait IWMPContentPartnerCallback_Impl: Sized { fn GetContentIDsInLibrary(&self, pccontentids: *mut u32, pprgids: *mut *mut u32) -> ::windows_core::Result<()>; fn RefreshLicenseComplete(&self, dwcookie: u32, contentid: u32, hrrefresh: ::windows_core::HRESULT) -> ::windows_core::Result<()>; fn ShowPopup(&self, lindex: i32, bstrparameters: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn VerifyPermissionComplete(&self, bstrpermission: &::windows_core::BSTR, pcontext: *const super::super::System::Variant::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::Result<()>; + fn VerifyPermissionComplete(&self, bstrpermission: &::windows_core::BSTR, pcontext: *const ::windows_core::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWMPContentPartnerCallback {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IWMPContentPartnerCallback_Vtbl { pub const fn new, Impl: IWMPContentPartnerCallback_Impl, const OFFSET: isize>() -> IWMPContentPartnerCallback_Vtbl { - unsafe extern "system" fn Notify, Impl: IWMPContentPartnerCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: WMPCallbackNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Notify, Impl: IWMPContentPartnerCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: WMPCallbackNotification, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Notify(::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&pcontext)).into() @@ -2528,7 +2524,7 @@ impl IWMPContentPartnerCallback_Vtbl { let this = (*this).get_impl(); this.ShowPopup(::core::mem::transmute_copy(&lindex), ::core::mem::transmute(&bstrparameters)).into() } - unsafe extern "system" fn VerifyPermissionComplete, Impl: IWMPContentPartnerCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::HRESULT { + unsafe extern "system" fn VerifyPermissionComplete, Impl: IWMPContentPartnerCallback_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, hrpermission: ::windows_core::HRESULT) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.VerifyPermissionComplete(::core::mem::transmute(&bstrpermission), ::core::mem::transmute_copy(&pcontext), ::core::mem::transmute_copy(&hrpermission)).into() @@ -2554,8 +2550,8 @@ impl IWMPContentPartnerCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPControls_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_isAvailable(&self, bstritem: &::windows_core::BSTR, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn play(&self) -> ::windows_core::Result<()>; @@ -2574,9 +2570,9 @@ pub trait IWMPControls_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetcurrentMarker(&self, lmarker: i32) -> ::windows_core::Result<()>; fn playItem(&self, piwmpmedia: ::core::option::Option<&IWMPMedia>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPControls {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPControls_Vtbl { pub const fn new, Impl: IWMPControls_Impl, const OFFSET: isize>() -> IWMPControls_Vtbl { unsafe extern "system" fn get_isAvailable, Impl: IWMPControls_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstritem: ::std::mem::MaybeUninit<::windows_core::BSTR>, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2689,14 +2685,14 @@ impl IWMPControls_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPControls2_Impl: Sized + IWMPControls_Impl { fn step(&self, lstep: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPControls2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPControls2_Vtbl { pub const fn new, Impl: IWMPControls2_Impl, const OFFSET: isize>() -> IWMPControls2_Vtbl { unsafe extern "system" fn step, Impl: IWMPControls2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lstep: i32) -> ::windows_core::HRESULT { @@ -2710,8 +2706,8 @@ impl IWMPControls2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPControls3_Impl: Sized + IWMPControls2_Impl { fn audioLanguageCount(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn getAudioLanguageID(&self, lindex: i32, pllangid: *mut i32) -> ::windows_core::Result<()>; @@ -2724,9 +2720,9 @@ pub trait IWMPControls3_Impl: Sized + IWMPControls2_Impl { fn currentPositionTimecode(&self, bstrtimecode: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetcurrentPositionTimecode(&self, bstrtimecode: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPControls3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPControls3_Vtbl { pub const fn new, Impl: IWMPControls3_Impl, const OFFSET: isize>() -> IWMPControls3_Vtbl { unsafe extern "system" fn audioLanguageCount, Impl: IWMPControls3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2824,8 +2820,8 @@ impl IWMPConvert_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPCore_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn close(&self) -> ::windows_core::Result<()>; fn URL(&self, pbstrurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2849,9 +2845,9 @@ pub trait IWMPCore_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn error(&self) -> ::windows_core::Result; fn status(&self, pbstrstatus: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPCore {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPCore_Vtbl { pub const fn new, Impl: IWMPCore_Impl, const OFFSET: isize>() -> IWMPCore_Vtbl { unsafe extern "system" fn close, Impl: IWMPCore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3048,14 +3044,14 @@ impl IWMPCore_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPCore2_Impl: Sized + IWMPCore_Impl { fn dvd(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPCore2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPCore2_Vtbl { pub const fn new, Impl: IWMPCore2_Impl, const OFFSET: isize>() -> IWMPCore2_Vtbl { unsafe extern "system" fn dvd, Impl: IWMPCore2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdvd: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3075,15 +3071,15 @@ impl IWMPCore2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPCore3_Impl: Sized + IWMPCore2_Impl { fn newPlaylist(&self, bstrname: &::windows_core::BSTR, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result; fn newMedia(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPCore3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPCore3_Vtbl { pub const fn new, Impl: IWMPCore3_Impl, const OFFSET: isize>() -> IWMPCore3_Vtbl { unsafe extern "system" fn newPlaylist, Impl: IWMPCore3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppplaylist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3118,8 +3114,8 @@ impl IWMPCore3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPDVD_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_isAvailable(&self, bstritem: &::windows_core::BSTR, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn domain(&self, strdomain: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3128,9 +3124,9 @@ pub trait IWMPDVD_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn back(&self) -> ::windows_core::Result<()>; fn resume(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPDVD {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPDVD_Vtbl { pub const fn new, Impl: IWMPDVD_Impl, const OFFSET: isize>() -> IWMPDVD_Vtbl { unsafe extern "system" fn get_isAvailable, Impl: IWMPDVD_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstritem: ::std::mem::MaybeUninit<::windows_core::BSTR>, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3177,8 +3173,8 @@ impl IWMPDVD_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPDownloadCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn id(&self, plid: *mut i32) -> ::windows_core::Result<()>; fn count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; @@ -3187,9 +3183,9 @@ pub trait IWMPDownloadCollection_Impl: Sized + super::super::System::Com::IDispa fn removeItem(&self, litem: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPDownloadCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPDownloadCollection_Vtbl { pub const fn new, Impl: IWMPDownloadCollection_Impl, const OFFSET: isize>() -> IWMPDownloadCollection_Vtbl { unsafe extern "system" fn id, Impl: IWMPDownloadCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plid: *mut i32) -> ::windows_core::HRESULT { @@ -3248,8 +3244,8 @@ impl IWMPDownloadCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPDownloadItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn sourceURL(&self, pbstrurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn size(&self, plsize: *mut i32) -> ::windows_core::Result<()>; @@ -3260,9 +3256,9 @@ pub trait IWMPDownloadItem_Impl: Sized + super::super::System::Com::IDispatch_Im fn resume(&self) -> ::windows_core::Result<()>; fn cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPDownloadItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPDownloadItem_Vtbl { pub const fn new, Impl: IWMPDownloadItem_Impl, const OFFSET: isize>() -> IWMPDownloadItem_Vtbl { unsafe extern "system" fn sourceURL, Impl: IWMPDownloadItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3321,14 +3317,14 @@ impl IWMPDownloadItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPDownloadItem2_Impl: Sized + IWMPDownloadItem_Impl { fn getItemInfo(&self, bstritemname: &::windows_core::BSTR, pbstrval: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPDownloadItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPDownloadItem2_Vtbl { pub const fn new, Impl: IWMPDownloadItem2_Impl, const OFFSET: isize>() -> IWMPDownloadItem2_Vtbl { unsafe extern "system" fn getItemInfo, Impl: IWMPDownloadItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstritemname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3342,15 +3338,15 @@ impl IWMPDownloadItem2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPDownloadManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn getDownloadCollection(&self, lcollectionid: i32) -> ::windows_core::Result; fn createDownloadCollection(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPDownloadManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPDownloadManager_Vtbl { pub const fn new, Impl: IWMPDownloadManager_Impl, const OFFSET: isize>() -> IWMPDownloadManager_Vtbl { unsafe extern "system" fn getDownloadCollection, Impl: IWMPDownloadManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcollectionid: i32, ppcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3538,17 +3534,17 @@ impl IWMPEffects2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPError_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn clearErrorQueue(&self) -> ::windows_core::Result<()>; fn errorCount(&self, plnumerrors: *mut i32) -> ::windows_core::Result<()>; fn get_item(&self, dwindex: i32) -> ::windows_core::Result; fn webHelp(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPError {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPError_Vtbl { pub const fn new, Impl: IWMPError_Impl, const OFFSET: isize>() -> IWMPError_Vtbl { unsafe extern "system" fn clearErrorQueue, Impl: IWMPError_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3589,18 +3585,18 @@ impl IWMPError_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPErrorItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn errorCode(&self, phr: *mut i32) -> ::windows_core::Result<()>; fn errorDescription(&self, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; - fn errorContext(&self, pvarcontext: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn errorContext(&self, pvarcontext: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn remedy(&self, plremedy: *mut i32) -> ::windows_core::Result<()>; fn customUrl(&self, pbstrcustomurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPErrorItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPErrorItem_Vtbl { pub const fn new, Impl: IWMPErrorItem_Impl, const OFFSET: isize>() -> IWMPErrorItem_Vtbl { unsafe extern "system" fn errorCode, Impl: IWMPErrorItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phr: *mut i32) -> ::windows_core::HRESULT { @@ -3613,7 +3609,7 @@ impl IWMPErrorItem_Vtbl { let this = (*this).get_impl(); this.errorDescription(::core::mem::transmute_copy(&pbstrdescription)).into() } - unsafe extern "system" fn errorContext, Impl: IWMPErrorItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcontext: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn errorContext, Impl: IWMPErrorItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcontext: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.errorContext(::core::mem::transmute_copy(&pvarcontext)).into() @@ -3641,14 +3637,14 @@ impl IWMPErrorItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPErrorItem2_Impl: Sized + IWMPErrorItem_Impl { fn condition(&self, plcondition: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPErrorItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPErrorItem2_Vtbl { pub const fn new, Impl: IWMPErrorItem2_Impl, const OFFSET: isize>() -> IWMPErrorItem2_Vtbl { unsafe extern "system" fn condition, Impl: IWMPErrorItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcondition: *mut i32) -> ::windows_core::HRESULT { @@ -4431,8 +4427,8 @@ impl IWMPLibrarySharingServices_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMedia_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_isIdentical(&self, piwmpmedia: ::core::option::Option<&IWMPMedia>, pvbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn sourceURL(&self, pbstrsourceurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4453,9 +4449,9 @@ pub trait IWMPMedia_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn isMemberOf(&self, pplaylist: ::core::option::Option<&IWMPPlaylist>, pvarfismemberof: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn isReadOnlyItem(&self, bstritemname: &::windows_core::BSTR, pvarfisreadonly: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMedia {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMedia_Vtbl { pub const fn new, Impl: IWMPMedia_Impl, const OFFSET: isize>() -> IWMPMedia_Vtbl { unsafe extern "system" fn get_isIdentical, Impl: IWMPMedia_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, piwmpmedia: *mut ::core::ffi::c_void, pvbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4574,14 +4570,14 @@ impl IWMPMedia_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMedia2_Impl: Sized + IWMPMedia_Impl { fn error(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMedia2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMedia2_Vtbl { pub const fn new, Impl: IWMPMedia2_Impl, const OFFSET: isize>() -> IWMPMedia2_Vtbl { unsafe extern "system" fn error, Impl: IWMPMedia2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppiwmperroritem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4601,15 +4597,15 @@ impl IWMPMedia2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMedia3_Impl: Sized + IWMPMedia2_Impl { fn getAttributeCountByType(&self, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, plcount: *mut i32) -> ::windows_core::Result<()>; - fn getItemInfoByType(&self, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, lindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getItemInfoByType(&self, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, lindex: i32, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMedia3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMedia3_Vtbl { pub const fn new, Impl: IWMPMedia3_Impl, const OFFSET: isize>() -> IWMPMedia3_Vtbl { unsafe extern "system" fn getAttributeCountByType, Impl: IWMPMedia3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4617,7 +4613,7 @@ impl IWMPMedia3_Vtbl { let this = (*this).get_impl(); this.getAttributeCountByType(::core::mem::transmute(&bstrtype), ::core::mem::transmute(&bstrlanguage), ::core::mem::transmute_copy(&plcount)).into() } - unsafe extern "system" fn getItemInfoByType, Impl: IWMPMedia3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getItemInfoByType, Impl: IWMPMedia3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lindex: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.getItemInfoByType(::core::mem::transmute(&bstrtype), ::core::mem::transmute(&bstrlanguage), ::core::mem::transmute_copy(&lindex), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -4632,8 +4628,8 @@ impl IWMPMedia3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMediaCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn add(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result; fn getAll(&self) -> ::windows_core::Result; @@ -4648,9 +4644,9 @@ pub trait IWMPMediaCollection_Impl: Sized + super::super::System::Com::IDispatch fn setDeleted(&self, pitem: ::core::option::Option<&IWMPMedia>, varfisdeleted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn isDeleted(&self, pitem: ::core::option::Option<&IWMPMedia>, pvarfisdeleted: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMediaCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMediaCollection_Vtbl { pub const fn new, Impl: IWMPMediaCollection_Impl, const OFFSET: isize>() -> IWMPMediaCollection_Vtbl { unsafe extern "system" fn add, Impl: IWMPMediaCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4781,17 +4777,17 @@ impl IWMPMediaCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMediaCollection2_Impl: Sized + IWMPMediaCollection_Impl { fn createQuery(&self) -> ::windows_core::Result; fn getPlaylistByQuery(&self, pquery: ::core::option::Option<&IWMPQuery>, bstrmediatype: &::windows_core::BSTR, bstrsortattribute: &::windows_core::BSTR, fsortascending: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; fn getStringCollectionByQuery(&self, bstrattribute: &::windows_core::BSTR, pquery: ::core::option::Option<&IWMPQuery>, bstrmediatype: &::windows_core::BSTR, bstrsortattribute: &::windows_core::BSTR, fsortascending: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; fn getByAttributeAndMediaType(&self, bstrattribute: &::windows_core::BSTR, bstrvalue: &::windows_core::BSTR, bstrmediatype: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMediaCollection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMediaCollection2_Vtbl { pub const fn new, Impl: IWMPMediaCollection2_Impl, const OFFSET: isize>() -> IWMPMediaCollection2_Vtbl { unsafe extern "system" fn createQuery, Impl: IWMPMediaCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppquery: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4877,17 +4873,17 @@ impl IWMPMediaPluginRegistrar_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMetadataPicture_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn mimeType(&self, pbstrmimetype: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn pictureType(&self, pbstrpicturetype: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn description(&self, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn URL(&self, pbstrurl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMetadataPicture {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMetadataPicture_Vtbl { pub const fn new, Impl: IWMPMetadataPicture_Impl, const OFFSET: isize>() -> IWMPMetadataPicture_Vtbl { unsafe extern "system" fn mimeType, Impl: IWMPMetadataPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrmimetype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4922,15 +4918,15 @@ impl IWMPMetadataPicture_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPMetadataText_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn description(&self, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn text(&self, pbstrtext: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPMetadataText {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPMetadataText_Vtbl { pub const fn new, Impl: IWMPMetadataText_Impl, const OFFSET: isize>() -> IWMPMetadataText_Vtbl { unsafe extern "system" fn description, Impl: IWMPMetadataText_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4953,8 +4949,8 @@ impl IWMPMetadataText_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPNetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn bandWidth(&self, plbandwidth: *mut i32) -> ::windows_core::Result<()>; fn recoveredPackets(&self, plrecoveredpackets: *mut i32) -> ::windows_core::Result<()>; @@ -4985,9 +4981,9 @@ pub trait IWMPNetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn encodedFrameRate(&self, plframerate: *mut i32) -> ::windows_core::Result<()>; fn framesSkipped(&self, plframes: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPNetwork {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPNetwork_Vtbl { pub const fn new, Impl: IWMPNetwork_Impl, const OFFSET: isize>() -> IWMPNetwork_Vtbl { unsafe extern "system" fn bandWidth, Impl: IWMPNetwork_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plbandwidth: *mut i32) -> ::windows_core::HRESULT { @@ -5336,8 +5332,8 @@ impl IWMPNodeWindowlessHost_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlayer_Impl: Sized + IWMPCore_Impl { fn enabled(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Setenabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5348,9 +5344,9 @@ pub trait IWMPPlayer_Impl: Sized + IWMPCore_Impl { fn SetuiMode(&self, bstrmode: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn uiMode(&self, pbstrmode: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlayer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlayer_Vtbl { pub const fn new, Impl: IWMPPlayer_Impl, const OFFSET: isize>() -> IWMPPlayer_Vtbl { unsafe extern "system" fn enabled, Impl: IWMPPlayer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5409,8 +5405,8 @@ impl IWMPPlayer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlayer2_Impl: Sized + IWMPCore_Impl { fn enabled(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Setenabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5425,9 +5421,9 @@ pub trait IWMPPlayer2_Impl: Sized + IWMPCore_Impl { fn windowlessVideo(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetwindowlessVideo(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlayer2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlayer2_Vtbl { pub const fn new, Impl: IWMPPlayer2_Impl, const OFFSET: isize>() -> IWMPPlayer2_Vtbl { unsafe extern "system" fn enabled, Impl: IWMPPlayer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5510,8 +5506,8 @@ impl IWMPPlayer2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlayer3_Impl: Sized + IWMPCore2_Impl { fn enabled(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Setenabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5526,9 +5522,9 @@ pub trait IWMPPlayer3_Impl: Sized + IWMPCore2_Impl { fn windowlessVideo(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetwindowlessVideo(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlayer3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlayer3_Vtbl { pub const fn new, Impl: IWMPPlayer3_Impl, const OFFSET: isize>() -> IWMPPlayer3_Vtbl { unsafe extern "system" fn enabled, Impl: IWMPPlayer3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5611,8 +5607,8 @@ impl IWMPPlayer3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlayer4_Impl: Sized + IWMPCore3_Impl { fn enabled(&self, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Setenabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5630,9 +5626,9 @@ pub trait IWMPPlayer4_Impl: Sized + IWMPCore3_Impl { fn playerApplication(&self) -> ::windows_core::Result; fn openPlayer(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlayer4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlayer4_Vtbl { pub const fn new, Impl: IWMPPlayer4_Impl, const OFFSET: isize>() -> IWMPPlayer4_Vtbl { unsafe extern "system" fn enabled, Impl: IWMPPlayer4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5739,17 +5735,17 @@ impl IWMPPlayer4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlayerApplication_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn switchToPlayerApplication(&self) -> ::windows_core::Result<()>; fn switchToControl(&self) -> ::windows_core::Result<()>; fn playerDocked(&self, pbplayerdocked: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn hasDisplay(&self, pbhasdisplay: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlayerApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlayerApplication_Vtbl { pub const fn new, Impl: IWMPPlayerApplication_Impl, const OFFSET: isize>() -> IWMPPlayerApplication_Vtbl { unsafe extern "system" fn switchToPlayerApplication, Impl: IWMPPlayerApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5838,8 +5834,8 @@ impl IWMPPlayerServices2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlaylist_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn name(&self, pbstrname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5856,9 +5852,9 @@ pub trait IWMPPlaylist_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn removeItem(&self, piwmpmedia: ::core::option::Option<&IWMPMedia>) -> ::windows_core::Result<()>; fn moveItem(&self, lindexold: i32, lindexnew: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlaylist {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlaylist_Vtbl { pub const fn new, Impl: IWMPPlaylist_Impl, const OFFSET: isize>() -> IWMPPlaylist_Vtbl { unsafe extern "system" fn count, Impl: IWMPPlaylist_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -5959,15 +5955,15 @@ impl IWMPPlaylist_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlaylistArray_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn item(&self, lindex: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlaylistArray {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlaylistArray_Vtbl { pub const fn new, Impl: IWMPPlaylistArray_Impl, const OFFSET: isize>() -> IWMPPlaylistArray_Vtbl { unsafe extern "system" fn count, Impl: IWMPPlaylistArray_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -5996,8 +5992,8 @@ impl IWMPPlaylistArray_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPPlaylistCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn newPlaylist(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn getAll(&self) -> ::windows_core::Result; @@ -6007,9 +6003,9 @@ pub trait IWMPPlaylistCollection_Impl: Sized + super::super::System::Com::IDispa fn isDeleted(&self, pitem: ::core::option::Option<&IWMPPlaylist>, pvarfisdeleted: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn importPlaylist(&self, pitem: ::core::option::Option<&IWMPPlaylist>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPPlaylistCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPPlaylistCollection_Vtbl { pub const fn new, Impl: IWMPPlaylistCollection_Impl, const OFFSET: isize>() -> IWMPPlaylistCollection_Vtbl { unsafe extern "system" fn newPlaylist, Impl: IWMPPlaylistCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6168,20 +6164,20 @@ impl IWMPPluginEnable_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IWMPPluginUI_Impl: Sized { fn SetCore(&self, pcore: ::core::option::Option<&IWMPCore>) -> ::windows_core::Result<()>; fn Create(&self, hwndparent: super::super::Foundation::HWND, phwndwindow: *mut super::super::Foundation::HWND) -> ::windows_core::Result<()>; fn Destroy(&self) -> ::windows_core::Result<()>; fn DisplayPropertyPage(&self, hwndparent: super::super::Foundation::HWND) -> ::windows_core::Result<()>; - fn GetProperty(&self, pwszname: &::windows_core::PCWSTR, pvarproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetProperty(&self, pwszname: &::windows_core::PCWSTR, pvarproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, pwszname: &::windows_core::PCWSTR, pvarproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetProperty(&self, pwszname: &::windows_core::PCWSTR, pvarproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn TranslateAccelerator(&self, lpmsg: *mut super::super::UI::WindowsAndMessaging::MSG) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IWMPPluginUI {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl IWMPPluginUI_Vtbl { pub const fn new, Impl: IWMPPluginUI_Impl, const OFFSET: isize>() -> IWMPPluginUI_Vtbl { unsafe extern "system" fn SetCore, Impl: IWMPPluginUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcore: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6204,12 +6200,12 @@ impl IWMPPluginUI_Vtbl { let this = (*this).get_impl(); this.DisplayPropertyPage(::core::mem::transmute_copy(&hwndparent)).into() } - unsafe extern "system" fn GetProperty, Impl: IWMPPluginUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IWMPPluginUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetProperty(::core::mem::transmute(&pwszname), ::core::mem::transmute_copy(&pvarproperty)).into() } - unsafe extern "system" fn SetProperty, Impl: IWMPPluginUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IWMPPluginUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&pwszname), ::core::mem::transmute_copy(&pvarproperty)).into() @@ -6234,15 +6230,15 @@ impl IWMPPluginUI_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPQuery_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn addCondition(&self, bstrattribute: &::windows_core::BSTR, bstroperator: &::windows_core::BSTR, bstrvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn beginNextGroup(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPQuery {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPQuery_Vtbl { pub const fn new, Impl: IWMPQuery_Impl, const OFFSET: isize>() -> IWMPQuery_Vtbl { unsafe extern "system" fn addCondition, Impl: IWMPQuery_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrattribute: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstroperator: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6364,8 +6360,8 @@ impl IWMPServices_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPSettings_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn get_isAvailable(&self, bstritem: &::windows_core::BSTR, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn autoStart(&self, pfautostart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -6391,9 +6387,9 @@ pub trait IWMPSettings_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn enableErrorDialogs(&self, pfenableerrordialogs: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetenableErrorDialogs(&self, fenableerrordialogs: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPSettings_Vtbl { pub const fn new, Impl: IWMPSettings_Impl, const OFFSET: isize>() -> IWMPSettings_Vtbl { unsafe extern "system" fn get_isAvailable, Impl: IWMPSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstritem: ::std::mem::MaybeUninit<::windows_core::BSTR>, pisavailable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -6542,16 +6538,16 @@ impl IWMPSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPSettings2_Impl: Sized + IWMPSettings_Impl { fn defaultAudioLanguage(&self, pllangid: *mut i32) -> ::windows_core::Result<()>; fn mediaAccessRights(&self, pbstrrights: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn requestMediaAccessRights(&self, bstrdesiredaccess: &::windows_core::BSTR, pvbaccepted: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPSettings2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPSettings2_Vtbl { pub const fn new, Impl: IWMPSettings2_Impl, const OFFSET: isize>() -> IWMPSettings2_Vtbl { unsafe extern "system" fn defaultAudioLanguage, Impl: IWMPSettings2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pllangid: *mut i32) -> ::windows_core::HRESULT { @@ -6597,15 +6593,15 @@ impl IWMPSkinManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPStringCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; fn item(&self, lindex: i32, pbstrstring: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPStringCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPStringCollection_Vtbl { pub const fn new, Impl: IWMPStringCollection_Impl, const OFFSET: isize>() -> IWMPStringCollection_Vtbl { unsafe extern "system" fn count, Impl: IWMPStringCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -6628,17 +6624,17 @@ impl IWMPStringCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMPStringCollection2_Impl: Sized + IWMPStringCollection_Impl { fn isIdentical(&self, piwmpstringcollection2: ::core::option::Option<&IWMPStringCollection2>, pvbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn getItemInfo(&self, lcollectionindex: i32, bstritemname: &::windows_core::BSTR, pbstrvalue: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn getAttributeCountByType(&self, lcollectionindex: i32, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, plcount: *mut i32) -> ::windows_core::Result<()>; - fn getItemInfoByType(&self, lcollectionindex: i32, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, lattributeindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getItemInfoByType(&self, lcollectionindex: i32, bstrtype: &::windows_core::BSTR, bstrlanguage: &::windows_core::BSTR, lattributeindex: i32, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMPStringCollection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMPStringCollection2_Vtbl { pub const fn new, Impl: IWMPStringCollection2_Impl, const OFFSET: isize>() -> IWMPStringCollection2_Vtbl { unsafe extern "system" fn isIdentical, Impl: IWMPStringCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, piwmpstringcollection2: *mut ::core::ffi::c_void, pvbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -6656,7 +6652,7 @@ impl IWMPStringCollection2_Vtbl { let this = (*this).get_impl(); this.getAttributeCountByType(::core::mem::transmute_copy(&lcollectionindex), ::core::mem::transmute(&bstrtype), ::core::mem::transmute(&bstrlanguage), ::core::mem::transmute_copy(&plcount)).into() } - unsafe extern "system" fn getItemInfoByType, Impl: IWMPStringCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lattributeindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getItemInfoByType, Impl: IWMPStringCollection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lattributeindex: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.getItemInfoByType(::core::mem::transmute_copy(&lcollectionindex), ::core::mem::transmute(&bstrtype), ::core::mem::transmute(&bstrlanguage), ::core::mem::transmute_copy(&lattributeindex), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -8596,12 +8592,12 @@ impl IXFeedsManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _WMPOCXEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _WMPOCXEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _WMPOCXEvents_Vtbl { pub const fn new, Impl: _WMPOCXEvents_Impl, const OFFSET: isize>() -> _WMPOCXEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/mod.rs index e84a1ca848..dabb05ca28 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/MediaPlayer/mod.rs @@ -1782,46 +1782,36 @@ impl IWMPContentPartner { { (::windows_core::Interface::vtable(self).SetCallback)(::windows_core::Interface::as_raw(self), pcallback.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Notify(&self, r#type: WMPPartnerNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Notify)(::windows_core::Interface::as_raw(self), r#type, pcontext).ok() + pub unsafe fn Notify(&self, r#type: WMPPartnerNotification, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Notify)(::windows_core::Interface::as_raw(self), r#type, ::core::mem::transmute(pcontext)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetItemInfo(&self, bstrinfoname: P0, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn GetItemInfo(&self, bstrinfoname: P0, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetItemInfo)(::windows_core::Interface::as_raw(self), bstrinfoname.into_param().abi(), pcontext, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetItemInfo)(::windows_core::Interface::as_raw(self), bstrinfoname.into_param().abi(), ::core::mem::transmute(pcontext), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetContentPartnerInfo(&self, bstrinfoname: P0) -> ::windows_core::Result + pub unsafe fn GetContentPartnerInfo(&self, bstrinfoname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetContentPartnerInfo)(::windows_core::Interface::as_raw(self), bstrinfoname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCommands(&self, location: P0, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: P1, prgitemids: &[u32], pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::Result<()> + pub unsafe fn GetCommands(&self, location: P0, plocationcontext: *const ::windows_core::VARIANT, itemlocation: P1, prgitemids: &[u32], pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetCommands)(::windows_core::Interface::as_raw(self), location.into_param().abi(), plocationcontext, itemlocation.into_param().abi(), prgitemids.len().try_into().unwrap(), ::core::mem::transmute(prgitemids.as_ptr()), pcitemids, pprgitems).ok() + (::windows_core::Interface::vtable(self).GetCommands)(::windows_core::Interface::as_raw(self), location.into_param().abi(), ::core::mem::transmute(plocationcontext), itemlocation.into_param().abi(), prgitemids.len().try_into().unwrap(), ::core::mem::transmute(prgitemids.as_ptr()), pcitemids, pprgitems).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeCommand(&self, dwcommandid: u32, location: P0, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: P1, rgitemids: &[u32]) -> ::windows_core::Result<()> + pub unsafe fn InvokeCommand(&self, dwcommandid: u32, location: P0, plocationcontext: *const ::windows_core::VARIANT, itemlocation: P1, rgitemids: &[u32]) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).InvokeCommand)(::windows_core::Interface::as_raw(self), dwcommandid, location.into_param().abi(), plocationcontext, itemlocation.into_param().abi(), rgitemids.len().try_into().unwrap(), ::core::mem::transmute(rgitemids.as_ptr())).ok() + (::windows_core::Interface::vtable(self).InvokeCommand)(::windows_core::Interface::as_raw(self), dwcommandid, location.into_param().abi(), ::core::mem::transmute(plocationcontext), itemlocation.into_param().abi(), rgitemids.len().try_into().unwrap(), ::core::mem::transmute(rgitemids.as_ptr())).ok() } pub unsafe fn CanBuySilent(&self, pinfo: P0, pbstrtotalprice: *mut ::windows_core::BSTR, psilentok: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()> where @@ -1835,11 +1825,9 @@ impl IWMPContentPartner { { (::windows_core::Interface::vtable(self).Buy)(::windows_core::Interface::as_raw(self), pinfo.into_param().abi(), cookie).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetStreamingURL(&self, st: WMPStreamingType, pstreamcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn GetStreamingURL(&self, st: WMPStreamingType, pstreamcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetStreamingURL)(::windows_core::Interface::as_raw(self), st, pstreamcontext, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetStreamingURL)(::windows_core::Interface::as_raw(self), st, ::core::mem::transmute(pstreamcontext), &mut result__).from_abi(result__) } pub unsafe fn Download(&self, pinfo: P0, cookie: u32) -> ::windows_core::Result<()> where @@ -1853,31 +1841,25 @@ impl IWMPContentPartner { { (::windows_core::Interface::vtable(self).DownloadTrackComplete)(::windows_core::Interface::as_raw(self), hrresult, contentid, downloadtrackparam.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RefreshLicense(&self, dwcookie: u32, flocal: P0, bstrurl: P1, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: P2, preasoncontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn RefreshLicense(&self, dwcookie: u32, flocal: P0, bstrurl: P1, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: P2, preasoncontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).RefreshLicense)(::windows_core::Interface::as_raw(self), dwcookie, flocal.into_param().abi(), bstrurl.into_param().abi(), r#type, contentid, bstrrefreshreason.into_param().abi(), preasoncontext).ok() + (::windows_core::Interface::vtable(self).RefreshLicense)(::windows_core::Interface::as_raw(self), dwcookie, flocal.into_param().abi(), bstrurl.into_param().abi(), r#type, contentid, bstrrefreshreason.into_param().abi(), ::core::mem::transmute(preasoncontext)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCatalogURL(&self, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::windows_core::BSTR, pexpirationdate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetCatalogURL)(::windows_core::Interface::as_raw(self), dwcatalogversion, dwcatalogschemaversion, cataloglcid, pdwnewcatalogversion, ::core::mem::transmute(pbstrcatalogurl), pexpirationdate).ok() + pub unsafe fn GetCatalogURL(&self, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::windows_core::BSTR, pexpirationdate: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetCatalogURL)(::windows_core::Interface::as_raw(self), dwcatalogversion, dwcatalogschemaversion, cataloglcid, pdwnewcatalogversion, ::core::mem::transmute(pbstrcatalogurl), ::core::mem::transmute(pexpirationdate)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetTemplate(&self, task: WMPTaskType, location: P0, pcontext: *const super::super::System::Variant::VARIANT, clicklocation: P1, pclickcontext: *const super::super::System::Variant::VARIANT, bstrfilter: P2, bstrviewparams: P3, pbstrtemplateurl: *mut ::windows_core::BSTR, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::Result<()> + pub unsafe fn GetTemplate(&self, task: WMPTaskType, location: P0, pcontext: *const ::windows_core::VARIANT, clicklocation: P1, pclickcontext: *const ::windows_core::VARIANT, bstrfilter: P2, bstrviewparams: P3, pbstrtemplateurl: *mut ::windows_core::BSTR, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, P3: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetTemplate)(::windows_core::Interface::as_raw(self), task, location.into_param().abi(), pcontext, clicklocation.into_param().abi(), pclickcontext, bstrfilter.into_param().abi(), bstrviewparams.into_param().abi(), ::core::mem::transmute(pbstrtemplateurl), ptemplatesize).ok() + (::windows_core::Interface::vtable(self).GetTemplate)(::windows_core::Interface::as_raw(self), task, location.into_param().abi(), ::core::mem::transmute(pcontext), clicklocation.into_param().abi(), ::core::mem::transmute(pclickcontext), bstrfilter.into_param().abi(), bstrviewparams.into_param().abi(), ::core::mem::transmute(pbstrtemplateurl), ptemplatesize).ok() } pub unsafe fn UpdateDevice(&self, bstrdevicename: P0) -> ::windows_core::Result<()> where @@ -1885,15 +1867,13 @@ impl IWMPContentPartner { { (::windows_core::Interface::vtable(self).UpdateDevice)(::windows_core::Interface::as_raw(self), bstrdevicename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetListContents(&self, location: P0, pcontext: *const super::super::System::Variant::VARIANT, bstrlisttype: P1, bstrparams: P2, dwlistcookie: u32) -> ::windows_core::Result<()> + pub unsafe fn GetListContents(&self, location: P0, pcontext: *const ::windows_core::VARIANT, bstrlisttype: P1, bstrparams: P2, dwlistcookie: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetListContents)(::windows_core::Interface::as_raw(self), location.into_param().abi(), pcontext, bstrlisttype.into_param().abi(), bstrparams.into_param().abi(), dwlistcookie).ok() + (::windows_core::Interface::vtable(self).GetListContents)(::windows_core::Interface::as_raw(self), location.into_param().abi(), ::core::mem::transmute(pcontext), bstrlisttype.into_param().abi(), bstrparams.into_param().abi(), dwlistcookie).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1934,13 +1914,11 @@ impl IWMPContentPartner { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CompareContainerListPrices)(::windows_core::Interface::as_raw(self), plistbase.into_param().abi(), plistcompare.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VerifyPermission(&self, bstrpermission: P0, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn VerifyPermission(&self, bstrpermission: P0, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).VerifyPermission)(::windows_core::Interface::as_raw(self), bstrpermission.into_param().abi(), pcontext).ok() + (::windows_core::Interface::vtable(self).VerifyPermission)(::windows_core::Interface::as_raw(self), bstrpermission.into_param().abi(), ::core::mem::transmute(pcontext)).ok() } } #[repr(C)] @@ -1948,51 +1926,21 @@ impl IWMPContentPartner { pub struct IWMPContentPartner_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub SetCallback: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Notify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: WMPPartnerNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Notify: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetItemInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetItemInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetContentPartnerInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetContentPartnerInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCommands: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCommands: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeCommand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcommandid: u32, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const super::super::System::Variant::VARIANT, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, rgitemids: *const u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeCommand: usize, + pub Notify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: WMPPartnerNotification, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetItemInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetContentPartnerInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinfoname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCommands: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, prgitemids: *const u32, pcitemids: *mut u32, pprgitems: *mut *mut WMPContextMenuInfo) -> ::windows_core::HRESULT, + pub InvokeCommand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcommandid: u32, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, plocationcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, itemlocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, citemids: u32, rgitemids: *const u32) -> ::windows_core::HRESULT, pub CanBuySilent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinfo: *mut ::core::ffi::c_void, pbstrtotalprice: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, psilentok: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Buy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinfo: *mut ::core::ffi::c_void, cookie: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetStreamingURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, st: WMPStreamingType, pstreamcontext: *const super::super::System::Variant::VARIANT, pbstrurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetStreamingURL: usize, + pub GetStreamingURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, st: WMPStreamingType, pstreamcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Download: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinfo: *mut ::core::ffi::c_void, cookie: u32) -> ::windows_core::HRESULT, pub DownloadTrackComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrresult: ::windows_core::HRESULT, contentid: u32, downloadtrackparam: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RefreshLicense: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: ::std::mem::MaybeUninit<::windows_core::BSTR>, preasoncontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RefreshLicense: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCatalogURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexpirationdate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCatalogURL: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetTemplate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, task: WMPTaskType, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, clicklocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, pclickcontext: *const super::super::System::Variant::VARIANT, bstrfilter: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrviewparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrtemplateurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetTemplate: usize, + pub RefreshLicense: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcookie: u32, flocal: super::super::Foundation::VARIANT_BOOL, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: WMPStreamingType, contentid: u32, bstrrefreshreason: ::std::mem::MaybeUninit<::windows_core::BSTR>, preasoncontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCatalogURL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcatalogversion: u32, dwcatalogschemaversion: u32, cataloglcid: u32, pdwnewcatalogversion: *mut u32, pbstrcatalogurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexpirationdate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetTemplate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, task: WMPTaskType, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, clicklocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, pclickcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrfilter: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrviewparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrtemplateurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, ptemplatesize: *mut WMPTemplateSize) -> ::windows_core::HRESULT, pub UpdateDevice: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdevicename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetListContents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, bstrlisttype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwlistcookie: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetListContents: usize, + pub GetListContents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrlisttype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwlistcookie: u32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Login: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, userinfo: super::super::System::Com::BLOB, pwdinfo: super::super::System::Com::BLOB, fusedcachedcreds: super::super::Foundation::VARIANT_BOOL, foktocache: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2005,18 +1953,13 @@ pub struct IWMPContentPartner_Vtbl { pub SendMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmsg: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrparam: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub StationEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrstationeventtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, stationid: u32, playlistindex: u32, trackid: u32, trackdata: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwsecondsplayed: u32) -> ::windows_core::HRESULT, pub CompareContainerListPrices: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plistbase: *mut ::core::ffi::c_void, plistcompare: *mut ::core::ffi::c_void, presult: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VerifyPermission: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VerifyPermission: usize, + pub VerifyPermission: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWMPContentPartnerCallback, IWMPContentPartnerCallback_Vtbl, 0x9e8f7da2_0695_403c_b697_da10fafaa676); ::windows_core::imp::interface_hierarchy!(IWMPContentPartnerCallback, ::windows_core::IUnknown); impl IWMPContentPartnerCallback { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Notify(&self, r#type: WMPCallbackNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Notify)(::windows_core::Interface::as_raw(self), r#type, pcontext).ok() + pub unsafe fn Notify(&self, r#type: WMPCallbackNotification, pcontext: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Notify)(::windows_core::Interface::as_raw(self), r#type, ::core::mem::transmute(pcontext)).ok() } pub unsafe fn BuyComplete(&self, hrresult: ::windows_core::HRESULT, dwbuycookie: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BuyComplete)(::windows_core::Interface::as_raw(self), hrresult, dwbuycookie).ok() @@ -2071,23 +2014,18 @@ impl IWMPContentPartnerCallback { { (::windows_core::Interface::vtable(self).ShowPopup)(::windows_core::Interface::as_raw(self), lindex, bstrparameters.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VerifyPermissionComplete(&self, bstrpermission: P0, pcontext: *const super::super::System::Variant::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::Result<()> + pub unsafe fn VerifyPermissionComplete(&self, bstrpermission: P0, pcontext: *const ::windows_core::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).VerifyPermissionComplete)(::windows_core::Interface::as_raw(self), bstrpermission.into_param().abi(), pcontext, hrpermission).ok() + (::windows_core::Interface::vtable(self).VerifyPermissionComplete)(::windows_core::Interface::as_raw(self), bstrpermission.into_param().abi(), ::core::mem::transmute(pcontext), hrpermission).ok() } } #[repr(C)] #[doc(hidden)] pub struct IWMPContentPartnerCallback_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Notify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: WMPCallbackNotification, pcontext: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Notify: usize, + pub Notify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: WMPCallbackNotification, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BuyComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrresult: ::windows_core::HRESULT, dwbuycookie: u32) -> ::windows_core::HRESULT, pub DownloadTrack: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cookie: u32, bstrtrackurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwservicetrackid: u32, bstrdownloadparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, hrdownload: ::windows_core::HRESULT) -> ::windows_core::HRESULT, pub GetCatalogVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwversion: *mut u32, pdwschemaversion: *mut u32, plcid: *mut u32) -> ::windows_core::HRESULT, @@ -2099,10 +2037,7 @@ pub struct IWMPContentPartnerCallback_Vtbl { pub GetContentIDsInLibrary: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pccontentids: *mut u32, pprgids: *mut *mut u32) -> ::windows_core::HRESULT, pub RefreshLicenseComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcookie: u32, contentid: u32, hrrefresh: ::windows_core::HRESULT) -> ::windows_core::HRESULT, pub ShowPopup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, bstrparameters: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VerifyPermissionComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const super::super::System::Variant::VARIANT, hrpermission: ::windows_core::HRESULT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VerifyPermissionComplete: usize, + pub VerifyPermissionComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpermission: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcontext: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, hrpermission: ::windows_core::HRESULT) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3400,10 +3335,8 @@ impl IWMPErrorItem { pub unsafe fn errorDescription(&self, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).errorDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pbstrdescription)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn errorContext(&self, pvarcontext: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).errorContext)(::windows_core::Interface::as_raw(self), pvarcontext).ok() + pub unsafe fn errorContext(&self, pvarcontext: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).errorContext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarcontext)).ok() } pub unsafe fn remedy(&self, plremedy: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).remedy)(::windows_core::Interface::as_raw(self), plremedy).ok() @@ -3419,10 +3352,7 @@ pub struct IWMPErrorItem_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub errorCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phr: *mut i32) -> ::windows_core::HRESULT, pub errorDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub errorContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcontext: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - errorContext: usize, + pub errorContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcontext: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub remedy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plremedy: *mut i32) -> ::windows_core::HRESULT, pub customUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrcustomurl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -3443,10 +3373,8 @@ impl IWMPErrorItem2 { pub unsafe fn errorDescription(&self, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.errorDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pbstrdescription)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn errorContext(&self, pvarcontext: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.errorContext)(::windows_core::Interface::as_raw(self), pvarcontext).ok() + pub unsafe fn errorContext(&self, pvarcontext: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.errorContext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarcontext)).ok() } pub unsafe fn remedy(&self, plremedy: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.remedy)(::windows_core::Interface::as_raw(self), plremedy).ok() @@ -5210,14 +5138,12 @@ impl IWMPMedia3 { { (::windows_core::Interface::vtable(self).getAttributeCountByType)(::windows_core::Interface::as_raw(self), bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), plcount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getItemInfoByType(&self, bstrtype: P0, bstrlanguage: P1, lindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn getItemInfoByType(&self, bstrtype: P0, bstrlanguage: P1, lindex: i32, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).getItemInfoByType)(::windows_core::Interface::as_raw(self), bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), lindex, pvarvalue).ok() + (::windows_core::Interface::vtable(self).getItemInfoByType)(::windows_core::Interface::as_raw(self), bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), lindex, ::core::mem::transmute(pvarvalue)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5226,10 +5152,7 @@ impl IWMPMedia3 { pub struct IWMPMedia3_Vtbl { pub base__: IWMPMedia2_Vtbl, pub getAttributeCountByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getItemInfoByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getItemInfoByType: usize, + pub getItemInfoByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lindex: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7198,21 +7121,17 @@ impl IWMPPluginUI { { (::windows_core::Interface::vtable(self).DisplayPropertyPage)(::windows_core::Interface::as_raw(self), hwndparent.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, pwszname: P0, pvarproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetProperty(&self, pwszname: P0, pvarproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), pvarproperty).ok() + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), ::core::mem::transmute(pvarproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, pwszname: P0, pvarproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, pwszname: P0, pvarproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), pvarproperty).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), pwszname.into_param().abi(), ::core::mem::transmute(pvarproperty)).ok() } #[doc = "Required features: `\"Win32_UI_WindowsAndMessaging\"`"] #[cfg(feature = "Win32_UI_WindowsAndMessaging")] @@ -7231,14 +7150,8 @@ pub struct IWMPPluginUI_Vtbl { pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: super::super::Foundation::HWND, phwndwindow: *mut super::super::Foundation::HWND) -> ::windows_core::HRESULT, pub Destroy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DisplayPropertyPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: super::super::Foundation::HWND) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszname: ::windows_core::PCWSTR, pvarproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_UI_WindowsAndMessaging")] pub TranslateAccelerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpmsg: *mut super::super::UI::WindowsAndMessaging::MSG) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_WindowsAndMessaging"))] @@ -7690,14 +7603,12 @@ impl IWMPStringCollection2 { { (::windows_core::Interface::vtable(self).getAttributeCountByType)(::windows_core::Interface::as_raw(self), lcollectionindex, bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), plcount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getItemInfoByType(&self, lcollectionindex: i32, bstrtype: P0, bstrlanguage: P1, lattributeindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn getItemInfoByType(&self, lcollectionindex: i32, bstrtype: P0, bstrlanguage: P1, lattributeindex: i32, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).getItemInfoByType)(::windows_core::Interface::as_raw(self), lcollectionindex, bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), lattributeindex, pvarvalue).ok() + (::windows_core::Interface::vtable(self).getItemInfoByType)(::windows_core::Interface::as_raw(self), lcollectionindex, bstrtype.into_param().abi(), bstrlanguage.into_param().abi(), lattributeindex, ::core::mem::transmute(pvarvalue)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -7711,10 +7622,7 @@ pub struct IWMPStringCollection2_Vtbl { isIdentical: usize, pub getItemInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstritemname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub getAttributeCountByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getItemInfoByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lattributeindex: i32, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getItemInfoByType: usize, + pub getItemInfoByType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcollectionindex: i32, bstrtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlanguage: ::std::mem::MaybeUninit<::windows_core::BSTR>, lattributeindex: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWMPSubscriptionService, IWMPSubscriptionService_Vtbl, 0x376055f8_2a59_4a73_9501_dca5273a7a10); ::windows_core::imp::interface_hierarchy!(IWMPSubscriptionService, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/impl.rs index 89976e55b6..700c520e0b 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/impl.rs @@ -82,22 +82,22 @@ impl IPhotoAcquireDeviceSelectionDialog_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IPhotoAcquireItem_Impl: Sized { fn GetItemName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetThumbnail(&self, sizethumbnail: &super::super::Foundation::SIZE) -> ::windows_core::Result; - fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; - fn SetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetStream(&self) -> ::windows_core::Result; fn CanDelete(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; fn GetSubItemCount(&self) -> ::windows_core::Result; fn GetSubItemAt(&self, nitemindex: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IPhotoAcquireItem {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IPhotoAcquireItem_Vtbl { pub const fn new, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>() -> IPhotoAcquireItem_Vtbl { unsafe extern "system" fn GetItemName, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstritemname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -122,7 +122,7 @@ impl IPhotoAcquireItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&key)) { @@ -133,7 +133,7 @@ impl IPhotoAcquireItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IPhotoAcquireItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&pv)).into() @@ -303,8 +303,6 @@ impl IPhotoAcquirePlugin_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPhotoAcquireProgressCB_Impl: Sized { fn Cancelled(&self) -> ::windows_core::Result; fn StartEnumeration(&self, pphotoacquiresource: ::core::option::Option<&IPhotoAcquireSource>) -> ::windows_core::Result<()>; @@ -324,11 +322,9 @@ pub trait IPhotoAcquireProgressCB_Impl: Sized { fn EndSession(&self, hr: ::windows_core::HRESULT) -> ::windows_core::Result<()>; fn GetDeleteAfterAcquire(&self) -> ::windows_core::Result; fn ErrorAdvise(&self, hr: ::windows_core::HRESULT, pszerrormessage: &::windows_core::PCWSTR, nmessagetype: ERROR_ADVISE_MESSAGE_TYPE) -> ::windows_core::Result; - fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: ::core::option::Option<&::windows_core::IUnknown>, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: ::core::option::Option<&::windows_core::IUnknown>, ppropvarresult: *mut ::windows_core::PROPVARIANT, ppropvardefault: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPhotoAcquireProgressCB {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPhotoAcquireProgressCB_Vtbl { pub const fn new, Impl: IPhotoAcquireProgressCB_Impl, const OFFSET: isize>() -> IPhotoAcquireProgressCB_Vtbl { unsafe extern "system" fn Cancelled, Impl: IPhotoAcquireProgressCB_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfcancelled: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -439,7 +435,7 @@ impl IPhotoAcquireProgressCB_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetUserInput, Impl: IPhotoAcquireProgressCB_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetUserInput, Impl: IPhotoAcquireProgressCB_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvardefault: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetUserInput(::core::mem::transmute_copy(&riidtype), ::windows_core::from_raw_borrowed(&punknown), ::core::mem::transmute_copy(&ppropvarresult), ::core::mem::transmute_copy(&ppropvardefault)).into() @@ -731,8 +727,8 @@ impl IPhotoProgressActionCB_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IPhotoProgressDialog_Impl: Sized { fn Create(&self, hwndparent: super::super::Foundation::HWND) -> ::windows_core::Result<()>; fn GetWindow(&self) -> ::windows_core::Result; @@ -751,11 +747,11 @@ pub trait IPhotoProgressDialog_Impl: Sized { fn SetActionLinkText(&self, pszcaption: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn ShowActionLink(&self, fshow: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn IsCancelled(&self) -> ::windows_core::Result; - fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: ::core::option::Option<&::windows_core::IUnknown>, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: ::core::option::Option<&::windows_core::IUnknown>, ppropvarresult: *mut ::windows_core::PROPVARIANT, ppropvardefault: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IPhotoProgressDialog {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))] impl IPhotoProgressDialog_Vtbl { pub const fn new, Impl: IPhotoProgressDialog_Impl, const OFFSET: isize>() -> IPhotoProgressDialog_Vtbl { unsafe extern "system" fn Create, Impl: IPhotoProgressDialog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwndparent: super::super::Foundation::HWND) -> ::windows_core::HRESULT { @@ -861,7 +857,7 @@ impl IPhotoProgressDialog_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetUserInput, Impl: IPhotoProgressDialog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetUserInput, Impl: IPhotoProgressDialog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvardefault: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetUserInput(::core::mem::transmute_copy(&riidtype), ::windows_core::from_raw_borrowed(&punknown), ::core::mem::transmute_copy(&ppropvarresult), ::core::mem::transmute_copy(&ppropvardefault)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/mod.rs index 0609b5618d..512ab6750d 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/PictureAcquisition/mod.rs @@ -79,16 +79,16 @@ impl IPhotoAcquireItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetThumbnail)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(sizethumbnail), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), key, pv).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn SetProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(pv)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -121,13 +121,13 @@ pub struct IPhotoAcquireItem_Vtbl { pub GetThumbnail: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sizethumbnail: super::super::Foundation::SIZE, phbmpthumbnail: *mut super::super::Graphics::Gdi::HBITMAP) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_Graphics_Gdi"))] GetThumbnail: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pv: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] SetProperty: usize, #[cfg(feature = "Win32_System_Com")] pub GetStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -313,13 +313,11 @@ impl IPhotoAcquireProgressCB { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ErrorAdvise)(::windows_core::Interface::as_raw(self), hr, pszerrormessage.into_param().abi(), nmessagetype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: P0, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> + pub unsafe fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: P0, ppropvarresult: *mut ::windows_core::PROPVARIANT, ppropvardefault: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, { - (::windows_core::Interface::vtable(self).GetUserInput)(::windows_core::Interface::as_raw(self), riidtype, punknown.into_param().abi(), ppropvarresult, ::core::mem::transmute(ppropvardefault.unwrap_or(::std::ptr::null()))).ok() + (::windows_core::Interface::vtable(self).GetUserInput)(::windows_core::Interface::as_raw(self), riidtype, punknown.into_param().abi(), ::core::mem::transmute(ppropvarresult), ::core::mem::transmute(ppropvardefault.unwrap_or(::std::ptr::null()))).ok() } } #[repr(C)] @@ -344,10 +342,7 @@ pub struct IPhotoAcquireProgressCB_Vtbl { pub EndSession: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hr: ::windows_core::HRESULT) -> ::windows_core::HRESULT, pub GetDeleteAfterAcquire: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfdeleteafteracquire: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub ErrorAdvise: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hr: ::windows_core::HRESULT, pszerrormessage: ::windows_core::PCWSTR, nmessagetype: ERROR_ADVISE_MESSAGE_TYPE, pnerroradviseresult: *mut ERROR_ADVISE_RESULT) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetUserInput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetUserInput: usize, + pub GetUserInput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvardefault: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPhotoAcquireSettings, IPhotoAcquireSettings_Vtbl, 0x00f2b868_dd67_487c_9553_049240767e91); ::windows_core::imp::interface_hierarchy!(IPhotoAcquireSettings, ::windows_core::IUnknown); @@ -595,13 +590,11 @@ impl IPhotoProgressDialog { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsCancelled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: P0, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> + pub unsafe fn GetUserInput(&self, riidtype: *const ::windows_core::GUID, punknown: P0, ppropvarresult: *mut ::windows_core::PROPVARIANT, ppropvardefault: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, { - (::windows_core::Interface::vtable(self).GetUserInput)(::windows_core::Interface::as_raw(self), riidtype, punknown.into_param().abi(), ppropvarresult, ::core::mem::transmute(ppropvardefault.unwrap_or(::std::ptr::null()))).ok() + (::windows_core::Interface::vtable(self).GetUserInput)(::windows_core::Interface::as_raw(self), riidtype, punknown.into_param().abi(), ::core::mem::transmute(ppropvarresult), ::core::mem::transmute(ppropvardefault.unwrap_or(::std::ptr::null()))).ok() } } #[repr(C)] @@ -628,10 +621,7 @@ pub struct IPhotoProgressDialog_Vtbl { pub SetActionLinkText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszcaption: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub ShowActionLink: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fshow: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub IsCancelled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfcancelled: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetUserInput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvardefault: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetUserInput: usize, + pub GetUserInput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riidtype: *const ::windows_core::GUID, punknown: *mut ::core::ffi::c_void, ppropvarresult: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvardefault: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUserInputString, IUserInputString_Vtbl, 0x00f243a1_205b_45ba_ae26_abbc53aa7a6f); ::windows_core::imp::interface_hierarchy!(IUserInputString, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/Media/Speech/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/Speech/impl.rs index 463fc5bbcc..33b51ae254 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/Speech/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/Speech/impl.rs @@ -435,8 +435,6 @@ impl ISpEventSource2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISpGrammarBuilder_Impl: Sized { fn ResetGrammar(&self, newlanguage: u16) -> ::windows_core::Result<()>; fn GetRule(&self, pszrulename: &::windows_core::PCWSTR, dwruleid: u32, dwattributes: u32, fcreateifnotexist: super::super::Foundation::BOOL, phinitialstate: *mut SPSTATEHANDLE) -> ::windows_core::Result<()>; @@ -447,9 +445,7 @@ pub trait ISpGrammarBuilder_Impl: Sized { fn AddResource(&self, hrulestate: SPSTATEHANDLE, pszresourcename: &::windows_core::PCWSTR, pszresourcevalue: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn Commit(&self, dwreserved: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISpGrammarBuilder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISpGrammarBuilder_Vtbl { pub const fn new, Impl: ISpGrammarBuilder_Impl, const OFFSET: isize>() -> ISpGrammarBuilder_Vtbl { unsafe extern "system" fn ResetGrammar, Impl: ISpGrammarBuilder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newlanguage: u16) -> ::windows_core::HRESULT { @@ -1157,17 +1153,13 @@ impl ISpPhoneticAlphabetSelection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISpPhrase_Impl: Sized { fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE>; fn GetSerializedPhrase(&self) -> ::windows_core::Result<*mut SPSERIALIZEDPHRASE>; fn GetText(&self, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut ::windows_core::PWSTR, pbdisplayattributes: *mut u8) -> ::windows_core::Result<()>; fn Discard(&self, dwvaluetypes: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISpPhrase {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISpPhrase_Vtbl { pub const fn new, Impl: ISpPhrase_Impl, const OFFSET: isize>() -> ISpPhrase_Vtbl { unsafe extern "system" fn GetPhrase, Impl: ISpPhrase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows_core::HRESULT { @@ -1214,16 +1206,16 @@ impl ISpPhrase_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpPhrase2_Impl: Sized + ISpPhrase_Impl { fn GetXMLResult(&self, ppszcomemxmlresult: *mut ::windows_core::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows_core::Result<()>; fn GetXMLErrorInfo(&self, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows_core::Result<()>; fn GetAudio(&self, ulstartelement: u32, celements: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpPhrase2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpPhrase2_Vtbl { pub const fn new, Impl: ISpPhrase2_Impl, const OFFSET: isize>() -> ISpPhrase2_Vtbl { unsafe extern "system" fn GetXMLResult, Impl: ISpPhrase2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszcomemxmlresult: *mut ::windows_core::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows_core::HRESULT { @@ -1258,15 +1250,11 @@ impl ISpPhrase2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISpPhraseAlt_Impl: Sized + ISpPhrase_Impl { fn GetAltInfo(&self, ppparent: *mut ::core::option::Option, pulstartelementinparent: *mut u32, pcelementsinparent: *mut u32, pcelementsinalt: *mut u32) -> ::windows_core::Result<()>; fn Commit(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISpPhraseAlt {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISpPhraseAlt_Vtbl { pub const fn new, Impl: ISpPhraseAlt_Impl, const OFFSET: isize>() -> ISpPhraseAlt_Vtbl { unsafe extern "system" fn GetAltInfo, Impl: ISpPhraseAlt_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppparent: *mut *mut ::core::ffi::c_void, pulstartelementinparent: *mut u32, pcelementsinparent: *mut u32, pcelementsinalt: *mut u32) -> ::windows_core::HRESULT { @@ -1537,8 +1525,8 @@ impl ISpRecoContext2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpRecoGrammar_Impl: Sized + ISpGrammarBuilder_Impl { fn GetGrammarId(&self, pullgrammarid: *mut u64) -> ::windows_core::Result<()>; fn GetRecoContext(&self) -> ::windows_core::Result; @@ -1559,9 +1547,9 @@ pub trait ISpRecoGrammar_Impl: Sized + ISpGrammarBuilder_Impl { fn SaveCmd(&self, pstream: ::core::option::Option<&super::super::System::Com::IStream>, ppszcomemerrortext: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn GetGrammarState(&self, pegrammarstate: *mut SPGRAMMARSTATE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpRecoGrammar {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpRecoGrammar_Vtbl { pub const fn new, Impl: ISpRecoGrammar_Impl, const OFFSET: isize>() -> ISpRecoGrammar_Vtbl { unsafe extern "system" fn GetGrammarId, Impl: ISpRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pullgrammarid: *mut u64) -> ::windows_core::HRESULT { @@ -1759,8 +1747,8 @@ impl ISpRecoGrammar2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] pub trait ISpRecoResult_Impl: Sized + ISpPhrase_Impl { fn GetResultTimes(&self, ptimes: *mut SPRECORESULTTIMES) -> ::windows_core::Result<()>; fn GetAlternates(&self, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::core::option::Option, pcphrasesreturned: *mut u32) -> ::windows_core::Result<()>; @@ -1770,9 +1758,9 @@ pub trait ISpRecoResult_Impl: Sized + ISpPhrase_Impl { fn ScaleAudio(&self, paudioformatid: *const ::windows_core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows_core::Result<()>; fn GetRecoContext(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ISpRecoResult {} -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ISpRecoResult_Vtbl { pub const fn new, Impl: ISpRecoResult_Impl, const OFFSET: isize>() -> ISpRecoResult_Vtbl { unsafe extern "system" fn GetResultTimes, Impl: ISpRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptimes: *mut SPRECORESULTTIMES) -> ::windows_core::HRESULT { @@ -1837,16 +1825,16 @@ impl ISpRecoResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] pub trait ISpRecoResult2_Impl: Sized + ISpRecoResult_Impl { fn CommitAlternate(&self, pphrasealt: ::core::option::Option<&ISpPhraseAlt>) -> ::windows_core::Result; fn CommitText(&self, ulstartelement: u32, celements: u32, pszcorrecteddata: &::windows_core::PCWSTR, ecommitflags: u32) -> ::windows_core::Result<()>; fn SetTextFeedback(&self, pszfeedback: &::windows_core::PCWSTR, fsuccessful: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ISpRecoResult2 {} -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ISpRecoResult2_Vtbl { pub const fn new, Impl: ISpRecoResult2_Impl, const OFFSET: isize>() -> ISpRecoResult2_Vtbl { unsafe extern "system" fn CommitAlternate, Impl: ISpRecoResult2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pphrasealt: *mut ::core::ffi::c_void, ppnewresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2626,15 +2614,15 @@ impl ISpVoice_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_Audio\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] pub trait ISpXMLRecoResult_Impl: Sized + ISpRecoResult_Impl { fn GetXMLResult(&self, ppszcomemxmlresult: *mut ::windows_core::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows_core::Result<()>; fn GetXMLErrorInfo(&self, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ISpXMLRecoResult {} -#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] impl ISpXMLRecoResult_Vtbl { pub const fn new, Impl: ISpXMLRecoResult_Impl, const OFFSET: isize>() -> ISpXMLRecoResult_Vtbl { unsafe extern "system" fn GetXMLResult, Impl: ISpXMLRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszcomemxmlresult: *mut ::windows_core::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows_core::HRESULT { @@ -2657,8 +2645,8 @@ impl ISpXMLRecoResult_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechAudio_Impl: Sized + ISpeechBaseStream_Impl { fn Status(&self) -> ::windows_core::Result; fn BufferInfo(&self) -> ::windows_core::Result; @@ -2670,9 +2658,9 @@ pub trait ISpeechAudio_Impl: Sized + ISpeechBaseStream_Impl { fn EventHandle(&self) -> ::windows_core::Result; fn SetState(&self, state: SpeechAudioState) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechAudio {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechAudio_Vtbl { pub const fn new, Impl: ISpeechAudio_Impl, const OFFSET: isize>() -> ISpeechAudio_Vtbl { unsafe extern "system" fn Status, Impl: ISpeechAudio_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, status: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2773,8 +2761,8 @@ impl ISpeechAudio_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechAudioBufferInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MinNotification(&self) -> ::windows_core::Result; fn SetMinNotification(&self, minnotification: i32) -> ::windows_core::Result<()>; @@ -2783,9 +2771,9 @@ pub trait ISpeechAudioBufferInfo_Impl: Sized + super::super::System::Com::IDispa fn EventBias(&self) -> ::windows_core::Result; fn SetEventBias(&self, eventbias: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechAudioBufferInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechAudioBufferInfo_Vtbl { pub const fn new, Impl: ISpeechAudioBufferInfo_Impl, const OFFSET: isize>() -> ISpeechAudioBufferInfo_Vtbl { unsafe extern "system" fn MinNotification, Impl: ISpeechAudioBufferInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, minnotification: *mut i32) -> ::windows_core::HRESULT { @@ -2850,8 +2838,8 @@ impl ISpeechAudioBufferInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechAudioFormat_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn SetType(&self, audioformat: SpeechAudioFormatType) -> ::windows_core::Result<()>; @@ -2860,9 +2848,9 @@ pub trait ISpeechAudioFormat_Impl: Sized + super::super::System::Com::IDispatch_ fn GetWaveFormatEx(&self) -> ::windows_core::Result; fn SetWaveFormatEx(&self, speechwaveformatex: ::core::option::Option<&ISpeechWaveFormatEx>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechAudioFormat {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechAudioFormat_Vtbl { pub const fn new, Impl: ISpeechAudioFormat_Impl, const OFFSET: isize>() -> ISpeechAudioFormat_Vtbl { unsafe extern "system" fn Type, Impl: ISpeechAudioFormat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audioformat: *mut SpeechAudioFormatType) -> ::windows_core::HRESULT { @@ -2927,18 +2915,18 @@ impl ISpeechAudioFormat_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechAudioStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FreeBufferSpace(&self) -> ::windows_core::Result; fn NonBlockingIO(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; - fn CurrentSeekPosition(&self) -> ::windows_core::Result; - fn CurrentDevicePosition(&self) -> ::windows_core::Result; + fn CurrentSeekPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CurrentDevicePosition(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechAudioStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechAudioStatus_Vtbl { pub const fn new, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>() -> ISpeechAudioStatus_Vtbl { unsafe extern "system" fn FreeBufferSpace, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, freebufferspace: *mut i32) -> ::windows_core::HRESULT { @@ -2974,7 +2962,7 @@ impl ISpeechAudioStatus_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CurrentSeekPosition, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentseekposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CurrentSeekPosition, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentseekposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CurrentSeekPosition() { @@ -2985,7 +2973,7 @@ impl ISpeechAudioStatus_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CurrentDevicePosition, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentdeviceposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CurrentDevicePosition, Impl: ISpeechAudioStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentdeviceposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CurrentDevicePosition() { @@ -3009,18 +2997,18 @@ impl ISpeechAudioStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechBaseStream_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Format(&self) -> ::windows_core::Result; fn putref_Format(&self, audioformat: ::core::option::Option<&ISpeechAudioFormat>) -> ::windows_core::Result<()>; - fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()>; - fn Write(&self, buffer: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Seek(&self, position: &super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result; + fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()>; + fn Write(&self, buffer: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Seek(&self, position: &::windows_core::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechBaseStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechBaseStream_Vtbl { pub const fn new, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>() -> ISpeechBaseStream_Vtbl { unsafe extern "system" fn Format, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audioformat: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3039,12 +3027,12 @@ impl ISpeechBaseStream_Vtbl { let this = (*this).get_impl(); this.putref_Format(::windows_core::from_raw_borrowed(&audioformat)).into() } - unsafe extern "system" fn Read, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Read, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Read(::core::mem::transmute_copy(&buffer), ::core::mem::transmute_copy(&numberofbytes), ::core::mem::transmute_copy(&bytesread)).into() } - unsafe extern "system" fn Write, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buffer: super::super::System::Variant::VARIANT, byteswritten: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Write, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buffer: ::std::mem::MaybeUninit<::windows_core::VARIANT>, byteswritten: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Write(::core::mem::transmute(&buffer)) { @@ -3055,7 +3043,7 @@ impl ISpeechBaseStream_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Seek, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType, newposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Seek, Impl: ISpeechBaseStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, position: ::std::mem::MaybeUninit<::windows_core::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Seek(::core::mem::transmute(&position), ::core::mem::transmute_copy(&origin)) { @@ -3079,15 +3067,15 @@ impl ISpeechBaseStream_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechCustomStream_Impl: Sized + ISpeechBaseStream_Impl { fn BaseStream(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn putref_BaseStream(&self, punkstream: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechCustomStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechCustomStream_Vtbl { pub const fn new, Impl: ISpeechCustomStream_Impl, const OFFSET: isize>() -> ISpeechCustomStream_Vtbl { unsafe extern "system" fn BaseStream, Impl: ISpeechCustomStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunkstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3116,11 +3104,11 @@ impl ISpeechCustomStream_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechDataKey_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn SetBinaryValue(&self, valuename: &::windows_core::BSTR, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetBinaryValue(&self, valuename: &::windows_core::BSTR) -> ::windows_core::Result; + fn SetBinaryValue(&self, valuename: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetBinaryValue(&self, valuename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetStringValue(&self, valuename: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetStringValue(&self, valuename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn SetLongValue(&self, valuename: &::windows_core::BSTR, value: i32) -> ::windows_core::Result<()>; @@ -3132,17 +3120,17 @@ pub trait ISpeechDataKey_Impl: Sized + super::super::System::Com::IDispatch_Impl fn EnumKeys(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn EnumValues(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechDataKey {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechDataKey_Vtbl { pub const fn new, Impl: ISpeechDataKey_Impl, const OFFSET: isize>() -> ISpeechDataKey_Vtbl { - unsafe extern "system" fn SetBinaryValue, Impl: ISpeechDataKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBinaryValue, Impl: ISpeechDataKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBinaryValue(::core::mem::transmute(&valuename), ::core::mem::transmute(&value)).into() } - unsafe extern "system" fn GetBinaryValue, Impl: ISpeechDataKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetBinaryValue, Impl: ISpeechDataKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetBinaryValue(::core::mem::transmute(&valuename)) { @@ -3259,15 +3247,15 @@ impl ISpeechDataKey_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechFileStream_Impl: Sized + ISpeechBaseStream_Impl { fn Open(&self, filename: &::windows_core::BSTR, filemode: SpeechStreamFileMode, doevents: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechFileStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechFileStream_Vtbl { pub const fn new, Impl: ISpeechFileStream_Impl, const OFFSET: isize>() -> ISpeechFileStream_Vtbl { unsafe extern "system" fn Open, Impl: ISpeechFileStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>, filemode: SpeechStreamFileMode, doevents: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3286,8 +3274,8 @@ impl ISpeechFileStream_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechGrammarRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Attributes(&self) -> ::windows_core::Result; fn InitialState(&self) -> ::windows_core::Result; @@ -3297,9 +3285,9 @@ pub trait ISpeechGrammarRule_Impl: Sized + super::super::System::Com::IDispatch_ fn AddResource(&self, resourcename: &::windows_core::BSTR, resourcevalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechGrammarRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechGrammarRule_Vtbl { pub const fn new, Impl: ISpeechGrammarRule_Impl, const OFFSET: isize>() -> ISpeechGrammarRule_Vtbl { unsafe extern "system" fn Attributes, Impl: ISpeechGrammarRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributes: *mut SpeechRuleAttributes) -> ::windows_core::HRESULT { @@ -3382,18 +3370,18 @@ impl ISpeechGrammarRule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechGrammarRuleState_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Rule(&self) -> ::windows_core::Result; fn Transitions(&self) -> ::windows_core::Result; - fn AddWordTransition(&self, deststate: ::core::option::Option<&ISpeechGrammarRuleState>, words: &::windows_core::BSTR, separators: &::windows_core::BSTR, r#type: SpeechGrammarWordType, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()>; - fn AddRuleTransition(&self, destinationstate: ::core::option::Option<&ISpeechGrammarRuleState>, rule: ::core::option::Option<&ISpeechGrammarRule>, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()>; - fn AddSpecialTransition(&self, destinationstate: ::core::option::Option<&ISpeechGrammarRuleState>, r#type: SpeechSpecialTransitionType, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()>; + fn AddWordTransition(&self, deststate: ::core::option::Option<&ISpeechGrammarRuleState>, words: &::windows_core::BSTR, separators: &::windows_core::BSTR, r#type: SpeechGrammarWordType, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()>; + fn AddRuleTransition(&self, destinationstate: ::core::option::Option<&ISpeechGrammarRuleState>, rule: ::core::option::Option<&ISpeechGrammarRule>, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()>; + fn AddSpecialTransition(&self, destinationstate: ::core::option::Option<&ISpeechGrammarRuleState>, r#type: SpeechSpecialTransitionType, propertyname: &::windows_core::BSTR, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechGrammarRuleState {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechGrammarRuleState_Vtbl { pub const fn new, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>() -> ISpeechGrammarRuleState_Vtbl { unsafe extern "system" fn Rule, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3418,17 +3406,17 @@ impl ISpeechGrammarRuleState_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddWordTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, deststate: *mut ::core::ffi::c_void, words: ::std::mem::MaybeUninit<::windows_core::BSTR>, separators: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: SpeechGrammarWordType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddWordTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, deststate: *mut ::core::ffi::c_void, words: ::std::mem::MaybeUninit<::windows_core::BSTR>, separators: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: SpeechGrammarWordType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddWordTransition(::windows_core::from_raw_borrowed(&deststate), ::core::mem::transmute(&words), ::core::mem::transmute(&separators), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&propertyvalue), ::core::mem::transmute_copy(&weight)).into() } - unsafe extern "system" fn AddRuleTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, rule: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddRuleTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, rule: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddRuleTransition(::windows_core::from_raw_borrowed(&destinationstate), ::windows_core::from_raw_borrowed(&rule), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&propertyvalue), ::core::mem::transmute_copy(&weight)).into() } - unsafe extern "system" fn AddSpecialTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, r#type: SpeechSpecialTransitionType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddSpecialTransition, Impl: ISpeechGrammarRuleState_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, r#type: SpeechSpecialTransitionType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddSpecialTransition(::windows_core::from_raw_borrowed(&destinationstate), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&propertyvalue), ::core::mem::transmute_copy(&weight)).into() @@ -3446,21 +3434,21 @@ impl ISpeechGrammarRuleState_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechGrammarRuleStateTransition_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn Text(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Rule(&self) -> ::windows_core::Result; - fn Weight(&self) -> ::windows_core::Result; + fn Weight(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn PropertyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn PropertyId(&self) -> ::windows_core::Result; - fn PropertyValue(&self) -> ::windows_core::Result; + fn PropertyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn NextState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechGrammarRuleStateTransition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechGrammarRuleStateTransition_Vtbl { pub const fn new, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>() -> ISpeechGrammarRuleStateTransition_Vtbl { unsafe extern "system" fn Type, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: *mut SpeechGrammarRuleStateTransitionType) -> ::windows_core::HRESULT { @@ -3496,7 +3484,7 @@ impl ISpeechGrammarRuleStateTransition_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Weight, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, weight: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Weight, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, weight: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Weight() { @@ -3529,7 +3517,7 @@ impl ISpeechGrammarRuleStateTransition_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PropertyValue, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PropertyValue, Impl: ISpeechGrammarRuleStateTransition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PropertyValue() { @@ -3567,16 +3555,16 @@ impl ISpeechGrammarRuleStateTransition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechGrammarRuleStateTransitions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechGrammarRuleStateTransitions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechGrammarRuleStateTransitions_Vtbl { pub const fn new, Impl: ISpeechGrammarRuleStateTransitions_Impl, const OFFSET: isize>() -> ISpeechGrammarRuleStateTransitions_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechGrammarRuleStateTransitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -3623,21 +3611,21 @@ impl ISpeechGrammarRuleStateTransitions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechGrammarRules_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn FindRule(&self, rulenameorid: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn FindRule(&self, rulenameorid: &::windows_core::VARIANT) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Dynamic(&self) -> ::windows_core::Result; fn Add(&self, rulename: &::windows_core::BSTR, attributes: SpeechRuleAttributes, ruleid: i32) -> ::windows_core::Result; fn Commit(&self) -> ::windows_core::Result<()>; - fn CommitAndSave(&self, errortext: *mut ::windows_core::BSTR, savestream: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CommitAndSave(&self, errortext: *mut ::windows_core::BSTR, savestream: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechGrammarRules {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechGrammarRules_Vtbl { pub const fn new, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>() -> ISpeechGrammarRules_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -3651,7 +3639,7 @@ impl ISpeechGrammarRules_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn FindRule, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulenameorid: super::super::System::Variant::VARIANT, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindRule, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulenameorid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindRule(::core::mem::transmute(&rulenameorid)) { @@ -3711,7 +3699,7 @@ impl ISpeechGrammarRules_Vtbl { let this = (*this).get_impl(); this.Commit().into() } - unsafe extern "system" fn CommitAndSave, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, errortext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, savestream: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CommitAndSave, Impl: ISpeechGrammarRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, errortext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, savestream: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CommitAndSave(::core::mem::transmute_copy(&errortext), ::core::mem::transmute_copy(&savestream)).into() @@ -3732,21 +3720,21 @@ impl ISpeechGrammarRules_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechLexicon_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GenerationId(&self) -> ::windows_core::Result; fn GetWords(&self, flags: SpeechLexiconType, generationid: *mut i32, words: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn AddPronunciation(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddPronunciationByPhoneIds(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddPronunciationByPhoneIds(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RemovePronunciation(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn RemovePronunciationByPhoneIds(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RemovePronunciationByPhoneIds(&self, bstrword: &::windows_core::BSTR, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetPronunciations(&self, bstrword: &::windows_core::BSTR, langid: i32, typeflags: SpeechLexiconType) -> ::windows_core::Result; fn GetGenerationChange(&self, generationid: *mut i32, ppwords: *mut ::core::option::Option) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechLexicon {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechLexicon_Vtbl { pub const fn new, Impl: ISpeechLexicon_Impl, const OFFSET: isize>() -> ISpeechLexicon_Vtbl { unsafe extern "system" fn GenerationId, Impl: ISpeechLexicon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, generationid: *mut i32) -> ::windows_core::HRESULT { @@ -3770,7 +3758,7 @@ impl ISpeechLexicon_Vtbl { let this = (*this).get_impl(); this.AddPronunciation(::core::mem::transmute(&bstrword), ::core::mem::transmute_copy(&langid), ::core::mem::transmute_copy(&partofspeech), ::core::mem::transmute(&bstrpronunciation)).into() } - unsafe extern "system" fn AddPronunciationByPhoneIds, Impl: ISpeechLexicon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPronunciationByPhoneIds, Impl: ISpeechLexicon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPronunciationByPhoneIds(::core::mem::transmute(&bstrword), ::core::mem::transmute_copy(&langid), ::core::mem::transmute_copy(&partofspeech), ::core::mem::transmute_copy(&phoneids)).into() @@ -3780,7 +3768,7 @@ impl ISpeechLexicon_Vtbl { let this = (*this).get_impl(); this.RemovePronunciation(::core::mem::transmute(&bstrword), ::core::mem::transmute_copy(&langid), ::core::mem::transmute_copy(&partofspeech), ::core::mem::transmute(&bstrpronunciation)).into() } - unsafe extern "system" fn RemovePronunciationByPhoneIds, Impl: ISpeechLexicon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemovePronunciationByPhoneIds, Impl: ISpeechLexicon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemovePronunciationByPhoneIds(::core::mem::transmute(&bstrword), ::core::mem::transmute_copy(&langid), ::core::mem::transmute_copy(&partofspeech), ::core::mem::transmute_copy(&phoneids)).into() @@ -3817,18 +3805,18 @@ impl ISpeechLexicon_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechLexiconPronunciation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn LangId(&self) -> ::windows_core::Result; fn PartOfSpeech(&self) -> ::windows_core::Result; - fn PhoneIds(&self) -> ::windows_core::Result; + fn PhoneIds(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Symbolic(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechLexiconPronunciation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechLexiconPronunciation_Vtbl { pub const fn new, Impl: ISpeechLexiconPronunciation_Impl, const OFFSET: isize>() -> ISpeechLexiconPronunciation_Vtbl { unsafe extern "system" fn Type, Impl: ISpeechLexiconPronunciation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lexicontype: *mut SpeechLexiconType) -> ::windows_core::HRESULT { @@ -3864,7 +3852,7 @@ impl ISpeechLexiconPronunciation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PhoneIds, Impl: ISpeechLexiconPronunciation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phoneids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PhoneIds, Impl: ISpeechLexiconPronunciation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phoneids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PhoneIds() { @@ -3899,16 +3887,16 @@ impl ISpeechLexiconPronunciation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechLexiconPronunciations_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechLexiconPronunciations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechLexiconPronunciations_Vtbl { pub const fn new, Impl: ISpeechLexiconPronunciations_Impl, const OFFSET: isize>() -> ISpeechLexiconPronunciations_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechLexiconPronunciations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -3955,17 +3943,17 @@ impl ISpeechLexiconPronunciations_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechLexiconWord_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LangId(&self) -> ::windows_core::Result; fn Type(&self) -> ::windows_core::Result; fn Word(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Pronunciations(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechLexiconWord {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechLexiconWord_Vtbl { pub const fn new, Impl: ISpeechLexiconWord_Impl, const OFFSET: isize>() -> ISpeechLexiconWord_Vtbl { unsafe extern "system" fn LangId, Impl: ISpeechLexiconWord_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, langid: *mut i32) -> ::windows_core::HRESULT { @@ -4024,16 +4012,16 @@ impl ISpeechLexiconWord_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechLexiconWords_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechLexiconWords {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechLexiconWords_Vtbl { pub const fn new, Impl: ISpeechLexiconWords_Impl, const OFFSET: isize>() -> ISpeechLexiconWords_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechLexiconWords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4080,8 +4068,8 @@ impl ISpeechLexiconWords_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechMMSysAudio_Impl: Sized + ISpeechAudio_Impl { fn DeviceId(&self) -> ::windows_core::Result; fn SetDeviceId(&self, deviceid: i32) -> ::windows_core::Result<()>; @@ -4089,9 +4077,9 @@ pub trait ISpeechMMSysAudio_Impl: Sized + ISpeechAudio_Impl { fn SetLineId(&self, lineid: i32) -> ::windows_core::Result<()>; fn MMHandle(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechMMSysAudio {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechMMSysAudio_Vtbl { pub const fn new, Impl: ISpeechMMSysAudio_Impl, const OFFSET: isize>() -> ISpeechMMSysAudio_Vtbl { unsafe extern "system" fn DeviceId, Impl: ISpeechMMSysAudio_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, deviceid: *mut i32) -> ::windows_core::HRESULT { @@ -4150,23 +4138,23 @@ impl ISpeechMMSysAudio_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechMemoryStream_Impl: Sized + ISpeechBaseStream_Impl { - fn SetData(&self, data: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetData(&self) -> ::windows_core::Result; + fn SetData(&self, data: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetData(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechMemoryStream {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechMemoryStream_Vtbl { pub const fn new, Impl: ISpeechMemoryStream_Impl, const OFFSET: isize>() -> ISpeechMemoryStream_Vtbl { - unsafe extern "system" fn SetData, Impl: ISpeechMemoryStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetData, Impl: ISpeechMemoryStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetData(::core::mem::transmute(&data)).into() } - unsafe extern "system" fn GetData, Impl: ISpeechMemoryStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetData, Impl: ISpeechMemoryStream_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetData() { @@ -4187,8 +4175,8 @@ impl ISpeechMemoryStream_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechObjectToken_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DataKey(&self) -> ::windows_core::Result; @@ -4200,13 +4188,13 @@ pub trait ISpeechObjectToken_Impl: Sized + super::super::System::Com::IDispatch_ fn Remove(&self, objectstorageclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetStorageFileName(&self, objectstorageclsid: &::windows_core::BSTR, keyname: &::windows_core::BSTR, filename: &::windows_core::BSTR, folder: SpeechTokenShellFolder) -> ::windows_core::Result<::windows_core::BSTR>; fn RemoveStorageFileName(&self, objectstorageclsid: &::windows_core::BSTR, keyname: &::windows_core::BSTR, deletefile: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT, object: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result; - fn DisplayUI(&self, hwnd: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT, object: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; + fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT, object: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result; + fn DisplayUI(&self, hwnd: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT, object: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn MatchesAttributes(&self, attributes: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechObjectToken {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechObjectToken_Vtbl { pub const fn new, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>() -> ISpeechObjectToken_Vtbl { unsafe extern "system" fn Id, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objectid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4301,7 +4289,7 @@ impl ISpeechObjectToken_Vtbl { let this = (*this).get_impl(); this.RemoveStorageFileName(::core::mem::transmute(&objectstorageclsid), ::core::mem::transmute(&keyname), ::core::mem::transmute_copy(&deletefile)).into() } - unsafe extern "system" fn IsUISupported, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, object: *mut ::core::ffi::c_void, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsUISupported, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut ::core::ffi::c_void, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsUISupported(::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata), ::windows_core::from_raw_borrowed(&object)) { @@ -4312,7 +4300,7 @@ impl ISpeechObjectToken_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DisplayUI, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, object: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn DisplayUI, Impl: ISpeechObjectToken_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DisplayUI(::core::mem::transmute_copy(&hwnd), ::core::mem::transmute(&title), ::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata), ::windows_core::from_raw_borrowed(&object)).into() @@ -4349,8 +4337,8 @@ impl ISpeechObjectToken_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechObjectTokenCategory_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDefault(&self, tokenid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4359,9 +4347,9 @@ pub trait ISpeechObjectTokenCategory_Impl: Sized + super::super::System::Com::ID fn GetDataKey(&self, location: SpeechDataKeyLocation) -> ::windows_core::Result; fn EnumerateTokens(&self, requiredattributes: &::windows_core::BSTR, optionalattributes: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechObjectTokenCategory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechObjectTokenCategory_Vtbl { pub const fn new, Impl: ISpeechObjectTokenCategory_Impl, const OFFSET: isize>() -> ISpeechObjectTokenCategory_Vtbl { unsafe extern "system" fn Id, Impl: ISpeechObjectTokenCategory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4432,16 +4420,16 @@ impl ISpeechObjectTokenCategory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechObjectTokens_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechObjectTokens {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechObjectTokens_Vtbl { pub const fn new, Impl: ISpeechObjectTokens_Impl, const OFFSET: isize>() -> ISpeechObjectTokens_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechObjectTokens_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4488,17 +4476,17 @@ impl ISpeechObjectTokens_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhoneConverter_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LanguageId(&self) -> ::windows_core::Result; fn SetLanguageId(&self, languageid: i32) -> ::windows_core::Result<()>; - fn PhoneToId(&self, phonemes: &::windows_core::BSTR) -> ::windows_core::Result; - fn IdToPhone(&self, idarray: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn PhoneToId(&self, phonemes: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn IdToPhone(&self, idarray: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhoneConverter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhoneConverter_Vtbl { pub const fn new, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>() -> ISpeechPhoneConverter_Vtbl { unsafe extern "system" fn LanguageId, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, languageid: *mut i32) -> ::windows_core::HRESULT { @@ -4517,7 +4505,7 @@ impl ISpeechPhoneConverter_Vtbl { let this = (*this).get_impl(); this.SetLanguageId(::core::mem::transmute_copy(&languageid)).into() } - unsafe extern "system" fn PhoneToId, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phonemes: ::std::mem::MaybeUninit<::windows_core::BSTR>, idarray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PhoneToId, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phonemes: ::std::mem::MaybeUninit<::windows_core::BSTR>, idarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PhoneToId(::core::mem::transmute(&phonemes)) { @@ -4528,7 +4516,7 @@ impl ISpeechPhoneConverter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn IdToPhone, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, idarray: super::super::System::Variant::VARIANT, phonemes: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn IdToPhone, Impl: ISpeechPhoneConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, idarray: ::std::mem::MaybeUninit<::windows_core::VARIANT>, phonemes: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IdToPhone(::core::mem::transmute(&idarray)) { @@ -4551,8 +4539,8 @@ impl ISpeechPhoneConverter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseAlternate_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RecoResult(&self) -> ::windows_core::Result; fn StartElementInResult(&self) -> ::windows_core::Result; @@ -4560,9 +4548,9 @@ pub trait ISpeechPhraseAlternate_Impl: Sized + super::super::System::Com::IDispa fn PhraseInfo(&self) -> ::windows_core::Result; fn Commit(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseAlternate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseAlternate_Vtbl { pub const fn new, Impl: ISpeechPhraseAlternate_Impl, const OFFSET: isize>() -> ISpeechPhraseAlternate_Vtbl { unsafe extern "system" fn RecoResult, Impl: ISpeechPhraseAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recoresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4627,16 +4615,16 @@ impl ISpeechPhraseAlternate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseAlternates_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseAlternates {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseAlternates_Vtbl { pub const fn new, Impl: ISpeechPhraseAlternates_Impl, const OFFSET: isize>() -> ISpeechPhraseAlternates_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechPhraseAlternates_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4683,8 +4671,8 @@ impl ISpeechPhraseAlternates_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseElement_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AudioTimeOffset(&self) -> ::windows_core::Result; fn AudioSizeTime(&self) -> ::windows_core::Result; @@ -4694,15 +4682,15 @@ pub trait ISpeechPhraseElement_Impl: Sized + super::super::System::Com::IDispatc fn RetainedSizeBytes(&self) -> ::windows_core::Result; fn DisplayText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LexicalForm(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Pronunciation(&self) -> ::windows_core::Result; + fn Pronunciation(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DisplayAttributes(&self) -> ::windows_core::Result; fn RequiredConfidence(&self) -> ::windows_core::Result; fn ActualConfidence(&self) -> ::windows_core::Result; fn EngineConfidence(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseElement_Vtbl { pub const fn new, Impl: ISpeechPhraseElement_Impl, const OFFSET: isize>() -> ISpeechPhraseElement_Vtbl { unsafe extern "system" fn AudioTimeOffset, Impl: ISpeechPhraseElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audiotimeoffset: *mut i32) -> ::windows_core::HRESULT { @@ -4793,7 +4781,7 @@ impl ISpeechPhraseElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Pronunciation, Impl: ISpeechPhraseElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pronunciation: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Pronunciation, Impl: ISpeechPhraseElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pronunciation: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Pronunciation() { @@ -4869,16 +4857,16 @@ impl ISpeechPhraseElement_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseElements_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseElements {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseElements_Vtbl { pub const fn new, Impl: ISpeechPhraseElements_Impl, const OFFSET: isize>() -> ISpeechPhraseElements_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechPhraseElements_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4925,13 +4913,13 @@ impl ISpeechPhraseElements_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LanguageId(&self) -> ::windows_core::Result; - fn GrammarId(&self) -> ::windows_core::Result; - fn StartTime(&self) -> ::windows_core::Result; - fn AudioStreamPosition(&self) -> ::windows_core::Result; + fn GrammarId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn StartTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AudioStreamPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn AudioSizeBytes(&self) -> ::windows_core::Result; fn RetainedSizeBytes(&self) -> ::windows_core::Result; fn AudioSizeTime(&self) -> ::windows_core::Result; @@ -4940,14 +4928,14 @@ pub trait ISpeechPhraseInfo_Impl: Sized + super::super::System::Com::IDispatch_I fn Elements(&self) -> ::windows_core::Result; fn Replacements(&self) -> ::windows_core::Result; fn EngineId(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn EnginePrivateData(&self) -> ::windows_core::Result; - fn SaveToMemory(&self) -> ::windows_core::Result; + fn EnginePrivateData(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetText(&self, startelement: i32, elements: i32, usereplacements: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::BSTR>; fn GetDisplayAttributes(&self, startelement: i32, elements: i32, usereplacements: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseInfo_Vtbl { pub const fn new, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>() -> ISpeechPhraseInfo_Vtbl { unsafe extern "system" fn LanguageId, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, languageid: *mut i32) -> ::windows_core::HRESULT { @@ -4961,7 +4949,7 @@ impl ISpeechPhraseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GrammarId, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammarid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GrammarId, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammarid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GrammarId() { @@ -4972,7 +4960,7 @@ impl ISpeechPhraseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn StartTime, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, starttime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StartTime, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, starttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StartTime() { @@ -4983,7 +4971,7 @@ impl ISpeechPhraseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AudioStreamPosition, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audiostreamposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AudioStreamPosition, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audiostreamposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AudioStreamPosition() { @@ -5082,7 +5070,7 @@ impl ISpeechPhraseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnginePrivateData, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, privatedata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnginePrivateData, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, privatedata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EnginePrivateData() { @@ -5093,7 +5081,7 @@ impl ISpeechPhraseInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SaveToMemory, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phraseblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SaveToMemory, Impl: ISpeechPhraseInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phraseblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SaveToMemory() { @@ -5150,17 +5138,17 @@ impl ISpeechPhraseInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseInfoBuilder_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn RestorePhraseFromMemory(&self, phraseinmemory: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn RestorePhraseFromMemory(&self, phraseinmemory: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseInfoBuilder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseInfoBuilder_Vtbl { pub const fn new, Impl: ISpeechPhraseInfoBuilder_Impl, const OFFSET: isize>() -> ISpeechPhraseInfoBuilder_Vtbl { - unsafe extern "system" fn RestorePhraseFromMemory, Impl: ISpeechPhraseInfoBuilder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phraseinmemory: *const super::super::System::Variant::VARIANT, phraseinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RestorePhraseFromMemory, Impl: ISpeechPhraseInfoBuilder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phraseinmemory: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, phraseinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RestorePhraseFromMemory(::core::mem::transmute_copy(&phraseinmemory)) { @@ -5180,16 +5168,16 @@ impl ISpeechPhraseInfoBuilder_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseProperties_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseProperties_Vtbl { pub const fn new, Impl: ISpeechPhraseProperties_Impl, const OFFSET: isize>() -> ISpeechPhraseProperties_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechPhraseProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -5236,12 +5224,12 @@ impl ISpeechPhraseProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseProperty_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Id(&self) -> ::windows_core::Result; - fn Value(&self) -> ::windows_core::Result; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn FirstElement(&self) -> ::windows_core::Result; fn NumberOfElements(&self) -> ::windows_core::Result; fn EngineConfidence(&self) -> ::windows_core::Result; @@ -5249,9 +5237,9 @@ pub trait ISpeechPhraseProperty_Impl: Sized + super::super::System::Com::IDispat fn Parent(&self) -> ::windows_core::Result; fn Children(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseProperty_Vtbl { pub const fn new, Impl: ISpeechPhraseProperty_Impl, const OFFSET: isize>() -> ISpeechPhraseProperty_Vtbl { unsafe extern "system" fn Name, Impl: ISpeechPhraseProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5276,7 +5264,7 @@ impl ISpeechPhraseProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: ISpeechPhraseProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISpeechPhraseProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -5370,17 +5358,17 @@ impl ISpeechPhraseProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseReplacement_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DisplayAttributes(&self) -> ::windows_core::Result; fn Text(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FirstElement(&self) -> ::windows_core::Result; fn NumberOfElements(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseReplacement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseReplacement_Vtbl { pub const fn new, Impl: ISpeechPhraseReplacement_Impl, const OFFSET: isize>() -> ISpeechPhraseReplacement_Vtbl { unsafe extern "system" fn DisplayAttributes, Impl: ISpeechPhraseReplacement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, displayattributes: *mut SpeechDisplayAttributes) -> ::windows_core::HRESULT { @@ -5439,16 +5427,16 @@ impl ISpeechPhraseReplacement_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseReplacements_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseReplacements {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseReplacements_Vtbl { pub const fn new, Impl: ISpeechPhraseReplacements_Impl, const OFFSET: isize>() -> ISpeechPhraseReplacements_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechPhraseReplacements_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -5495,8 +5483,8 @@ impl ISpeechPhraseReplacements_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Id(&self) -> ::windows_core::Result; @@ -5507,9 +5495,9 @@ pub trait ISpeechPhraseRule_Impl: Sized + super::super::System::Com::IDispatch_I fn Confidence(&self) -> ::windows_core::Result; fn EngineConfidence(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseRule_Vtbl { pub const fn new, Impl: ISpeechPhraseRule_Impl, const OFFSET: isize>() -> ISpeechPhraseRule_Vtbl { unsafe extern "system" fn Name, Impl: ISpeechPhraseRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5616,16 +5604,16 @@ impl ISpeechPhraseRule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechPhraseRules_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechPhraseRules {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseRules_Vtbl { pub const fn new, Impl: ISpeechPhraseRules_Impl, const OFFSET: isize>() -> ISpeechPhraseRules_Vtbl { unsafe extern "system" fn Count, Impl: ISpeechPhraseRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -5672,8 +5660,8 @@ impl ISpeechPhraseRules_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Recognizer(&self) -> ::windows_core::Result; fn AudioInputInterferenceStatus(&self) -> ::windows_core::Result; @@ -5696,14 +5684,14 @@ pub trait ISpeechRecoContext_Impl: Sized + super::super::System::Com::IDispatch_ fn RetainedAudioFormat(&self) -> ::windows_core::Result; fn Pause(&self) -> ::windows_core::Result<()>; fn Resume(&self) -> ::windows_core::Result<()>; - fn CreateGrammar(&self, grammarid: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateResultFromMemory(&self, resultblock: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Bookmark(&self, options: SpeechBookmarkOptions, streampos: &super::super::System::Variant::VARIANT, bookmarkid: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CreateGrammar(&self, grammarid: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateResultFromMemory(&self, resultblock: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Bookmark(&self, options: SpeechBookmarkOptions, streampos: &::windows_core::VARIANT, bookmarkid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetAdaptationData(&self, adaptationstring: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoContext_Vtbl { pub const fn new, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>() -> ISpeechRecoContext_Vtbl { unsafe extern "system" fn Recognizer, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recognizer: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5877,7 +5865,7 @@ impl ISpeechRecoContext_Vtbl { let this = (*this).get_impl(); this.Resume().into() } - unsafe extern "system" fn CreateGrammar, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammarid: super::super::System::Variant::VARIANT, grammar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateGrammar, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammarid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, grammar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateGrammar(::core::mem::transmute(&grammarid)) { @@ -5888,7 +5876,7 @@ impl ISpeechRecoContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateResultFromMemory, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *const super::super::System::Variant::VARIANT, result: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateResultFromMemory, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, result: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateResultFromMemory(::core::mem::transmute_copy(&resultblock)) { @@ -5899,7 +5887,7 @@ impl ISpeechRecoContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Bookmark, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, options: SpeechBookmarkOptions, streampos: super::super::System::Variant::VARIANT, bookmarkid: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Bookmark, Impl: ISpeechRecoContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, options: SpeechBookmarkOptions, streampos: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bookmarkid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Bookmark(::core::mem::transmute_copy(&options), ::core::mem::transmute(&streampos), ::core::mem::transmute(&bookmarkid)).into() @@ -5942,10 +5930,10 @@ impl ISpeechRecoContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoGrammar_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn Id(&self) -> ::windows_core::Result; + fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn RecoContext(&self) -> ::windows_core::Result; fn SetState(&self, state: SpeechGrammarState) -> ::windows_core::Result<()>; fn State(&self) -> ::windows_core::Result; @@ -5953,9 +5941,9 @@ pub trait ISpeechRecoGrammar_Impl: Sized + super::super::System::Com::IDispatch_ fn Reset(&self, newlanguage: i32) -> ::windows_core::Result<()>; fn CmdLoadFromFile(&self, filename: &::windows_core::BSTR, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; fn CmdLoadFromObject(&self, classid: &::windows_core::BSTR, grammarname: &::windows_core::BSTR, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; - fn CmdLoadFromResource(&self, hmodule: i32, resourcename: &super::super::System::Variant::VARIANT, resourcetype: &super::super::System::Variant::VARIANT, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; - fn CmdLoadFromMemory(&self, grammardata: &super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; - fn CmdLoadFromProprietaryGrammar(&self, proprietaryguid: &::windows_core::BSTR, proprietarystring: &::windows_core::BSTR, proprietarydata: &super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; + fn CmdLoadFromResource(&self, hmodule: i32, resourcename: &::windows_core::VARIANT, resourcetype: &::windows_core::VARIANT, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; + fn CmdLoadFromMemory(&self, grammardata: &::windows_core::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; + fn CmdLoadFromProprietaryGrammar(&self, proprietaryguid: &::windows_core::BSTR, proprietarystring: &::windows_core::BSTR, proprietarydata: &::windows_core::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; fn CmdSetRuleState(&self, name: &::windows_core::BSTR, state: SpeechRuleState) -> ::windows_core::Result<()>; fn CmdSetRuleIdState(&self, ruleid: i32, state: SpeechRuleState) -> ::windows_core::Result<()>; fn DictationLoad(&self, topicname: &::windows_core::BSTR, loadoption: SpeechLoadOption) -> ::windows_core::Result<()>; @@ -5965,12 +5953,12 @@ pub trait ISpeechRecoGrammar_Impl: Sized + super::super::System::Com::IDispatch_ fn SetTextSelection(&self, info: ::core::option::Option<&ISpeechTextSelectionInformation>) -> ::windows_core::Result<()>; fn IsPronounceable(&self, word: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoGrammar {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoGrammar_Vtbl { pub const fn new, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>() -> ISpeechRecoGrammar_Vtbl { - unsafe extern "system" fn Id, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Id, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Id() { @@ -6034,17 +6022,17 @@ impl ISpeechRecoGrammar_Vtbl { let this = (*this).get_impl(); this.CmdLoadFromObject(::core::mem::transmute(&classid), ::core::mem::transmute(&grammarname), ::core::mem::transmute_copy(&loadoption)).into() } - unsafe extern "system" fn CmdLoadFromResource, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hmodule: i32, resourcename: super::super::System::Variant::VARIANT, resourcetype: super::super::System::Variant::VARIANT, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { + unsafe extern "system" fn CmdLoadFromResource, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hmodule: i32, resourcename: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resourcetype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CmdLoadFromResource(::core::mem::transmute_copy(&hmodule), ::core::mem::transmute(&resourcename), ::core::mem::transmute(&resourcetype), ::core::mem::transmute_copy(&languageid), ::core::mem::transmute_copy(&loadoption)).into() } - unsafe extern "system" fn CmdLoadFromMemory, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammardata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { + unsafe extern "system" fn CmdLoadFromMemory, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grammardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CmdLoadFromMemory(::core::mem::transmute(&grammardata), ::core::mem::transmute_copy(&loadoption)).into() } - unsafe extern "system" fn CmdLoadFromProprietaryGrammar, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proprietaryguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarystring: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarydata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { + unsafe extern "system" fn CmdLoadFromProprietaryGrammar, Impl: ISpeechRecoGrammar_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proprietaryguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarystring: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarydata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CmdLoadFromProprietaryGrammar(::core::mem::transmute(&proprietaryguid), ::core::mem::transmute(&proprietarystring), ::core::mem::transmute(&proprietarydata), ::core::mem::transmute_copy(&loadoption)).into() @@ -6122,8 +6110,8 @@ impl ISpeechRecoGrammar_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoResult_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RecoContext(&self) -> ::windows_core::Result; fn Times(&self) -> ::windows_core::Result; @@ -6133,12 +6121,12 @@ pub trait ISpeechRecoResult_Impl: Sized + super::super::System::Com::IDispatch_I fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows_core::Result; fn Audio(&self, startelement: i32, elements: i32) -> ::windows_core::Result; fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows_core::Result; - fn SaveToMemory(&self) -> ::windows_core::Result; + fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoResult_Vtbl { pub const fn new, Impl: ISpeechRecoResult_Impl, const OFFSET: isize>() -> ISpeechRecoResult_Vtbl { unsafe extern "system" fn RecoContext, Impl: ISpeechRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recocontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6223,7 +6211,7 @@ impl ISpeechRecoResult_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SaveToMemory, Impl: ISpeechRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SaveToMemory, Impl: ISpeechRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SaveToMemory() { @@ -6257,14 +6245,14 @@ impl ISpeechRecoResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoResult2_Impl: Sized + ISpeechRecoResult_Impl { fn SetTextFeedback(&self, feedback: &::windows_core::BSTR, wassuccessful: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoResult2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoResult2_Vtbl { pub const fn new, Impl: ISpeechRecoResult2_Impl, const OFFSET: isize>() -> ISpeechRecoResult2_Vtbl { unsafe extern "system" fn SetTextFeedback, Impl: ISpeechRecoResult2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, feedback: ::std::mem::MaybeUninit<::windows_core::BSTR>, wassuccessful: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -6278,8 +6266,8 @@ impl ISpeechRecoResult2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoResultDispatch_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RecoContext(&self) -> ::windows_core::Result; fn Times(&self) -> ::windows_core::Result; @@ -6289,15 +6277,15 @@ pub trait ISpeechRecoResultDispatch_Impl: Sized + super::super::System::Com::IDi fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows_core::Result; fn Audio(&self, startelement: i32, elements: i32) -> ::windows_core::Result; fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows_core::Result; - fn SaveToMemory(&self) -> ::windows_core::Result; + fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows_core::Result<()>; fn GetXMLResult(&self, options: SPXMLRESULTOPTIONS) -> ::windows_core::Result<::windows_core::BSTR>; fn GetXMLErrorInfo(&self, linenumber: *mut i32, scriptline: *mut ::windows_core::BSTR, source: *mut ::windows_core::BSTR, description: *mut ::windows_core::BSTR, resultcode: *mut ::windows_core::HRESULT, iserror: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetTextFeedback(&self, feedback: &::windows_core::BSTR, wassuccessful: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoResultDispatch {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoResultDispatch_Vtbl { pub const fn new, Impl: ISpeechRecoResultDispatch_Impl, const OFFSET: isize>() -> ISpeechRecoResultDispatch_Vtbl { unsafe extern "system" fn RecoContext, Impl: ISpeechRecoResultDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recocontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6382,7 +6370,7 @@ impl ISpeechRecoResultDispatch_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SaveToMemory, Impl: ISpeechRecoResultDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SaveToMemory, Impl: ISpeechRecoResultDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SaveToMemory() { @@ -6440,20 +6428,20 @@ impl ISpeechRecoResultDispatch_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecoResultTimes_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn StreamTime(&self) -> ::windows_core::Result; - fn Length(&self) -> ::windows_core::Result; + fn StreamTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Length(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn TickCount(&self) -> ::windows_core::Result; - fn OffsetFromStart(&self) -> ::windows_core::Result; + fn OffsetFromStart(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecoResultTimes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecoResultTimes_Vtbl { pub const fn new, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>() -> ISpeechRecoResultTimes_Vtbl { - unsafe extern "system" fn StreamTime, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, time: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StreamTime, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, time: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StreamTime() { @@ -6464,7 +6452,7 @@ impl ISpeechRecoResultTimes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Length, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, length: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Length, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, length: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Length() { @@ -6486,7 +6474,7 @@ impl ISpeechRecoResultTimes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OffsetFromStart, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, offsetfromstart: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OffsetFromStart, Impl: ISpeechRecoResultTimes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, offsetfromstart: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OffsetFromStart() { @@ -6509,8 +6497,8 @@ impl ISpeechRecoResultTimes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecognizer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn putref_Recognizer(&self, recognizer: ::core::option::Option<&ISpeechObjectToken>) -> ::windows_core::Result<()>; fn Recognizer(&self) -> ::windows_core::Result; @@ -6526,22 +6514,22 @@ pub trait ISpeechRecognizer_Impl: Sized + super::super::System::Com::IDispatch_I fn Status(&self) -> ::windows_core::Result; fn putref_Profile(&self, profile: ::core::option::Option<&ISpeechObjectToken>) -> ::windows_core::Result<()>; fn Profile(&self) -> ::windows_core::Result; - fn EmulateRecognition(&self, textelements: &super::super::System::Variant::VARIANT, elementdisplayattributes: *const super::super::System::Variant::VARIANT, languageid: i32) -> ::windows_core::Result<()>; + fn EmulateRecognition(&self, textelements: &::windows_core::VARIANT, elementdisplayattributes: *const ::windows_core::VARIANT, languageid: i32) -> ::windows_core::Result<()>; fn CreateRecoContext(&self) -> ::windows_core::Result; fn GetFormat(&self, r#type: SpeechFormatType) -> ::windows_core::Result; fn SetPropertyNumber(&self, name: &::windows_core::BSTR, value: i32) -> ::windows_core::Result; fn GetPropertyNumber(&self, name: &::windows_core::BSTR, value: *mut i32, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetPropertyString(&self, name: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result; fn GetPropertyString(&self, name: &::windows_core::BSTR, value: *mut ::windows_core::BSTR, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DisplayUI(&self, hwndparent: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn DisplayUI(&self, hwndparent: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetRecognizers(&self, requiredattributes: &::windows_core::BSTR, optionalattributes: &::windows_core::BSTR) -> ::windows_core::Result; fn GetAudioInputs(&self, requiredattributes: &::windows_core::BSTR, optionalattributes: &::windows_core::BSTR) -> ::windows_core::Result; fn GetProfiles(&self, requiredattributes: &::windows_core::BSTR, optionalattributes: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecognizer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecognizer_Vtbl { pub const fn new, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>() -> ISpeechRecognizer_Vtbl { unsafe extern "system" fn putref_Recognizer, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recognizer: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6662,7 +6650,7 @@ impl ISpeechRecognizer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EmulateRecognition, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, textelements: super::super::System::Variant::VARIANT, elementdisplayattributes: *const super::super::System::Variant::VARIANT, languageid: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn EmulateRecognition, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, textelements: ::std::mem::MaybeUninit<::windows_core::VARIANT>, elementdisplayattributes: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, languageid: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EmulateRecognition(::core::mem::transmute(&textelements), ::core::mem::transmute_copy(&elementdisplayattributes), ::core::mem::transmute_copy(&languageid)).into() @@ -6721,7 +6709,7 @@ impl ISpeechRecognizer_Vtbl { let this = (*this).get_impl(); this.GetPropertyString(::core::mem::transmute(&name), ::core::mem::transmute_copy(&value), ::core::mem::transmute_copy(&supported)).into() } - unsafe extern "system" fn IsUISupported, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsUISupported, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsUISupported(::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata)) { @@ -6732,7 +6720,7 @@ impl ISpeechRecognizer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DisplayUI, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DisplayUI, Impl: ISpeechRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DisplayUI(::core::mem::transmute_copy(&hwndparent), ::core::mem::transmute(&title), ::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata)).into() @@ -6804,19 +6792,19 @@ impl ISpeechRecognizer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechRecognizerStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AudioStatus(&self) -> ::windows_core::Result; - fn CurrentStreamPosition(&self) -> ::windows_core::Result; + fn CurrentStreamPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn CurrentStreamNumber(&self) -> ::windows_core::Result; fn NumberOfActiveRules(&self) -> ::windows_core::Result; fn ClsidEngine(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn SupportedLanguages(&self) -> ::windows_core::Result; + fn SupportedLanguages(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechRecognizerStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechRecognizerStatus_Vtbl { pub const fn new, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>() -> ISpeechRecognizerStatus_Vtbl { unsafe extern "system" fn AudioStatus, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, audiostatus: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6830,7 +6818,7 @@ impl ISpeechRecognizerStatus_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CurrentStreamPosition, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcurrentstreampos: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CurrentStreamPosition, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcurrentstreampos: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CurrentStreamPosition() { @@ -6874,7 +6862,7 @@ impl ISpeechRecognizerStatus_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SupportedLanguages, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, supportedlanguages: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SupportedLanguages, Impl: ISpeechRecognizerStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, supportedlanguages: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SupportedLanguages() { @@ -6899,16 +6887,16 @@ impl ISpeechRecognizerStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechResourceLoader_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LoadResource(&self, bstrresourceuri: &::windows_core::BSTR, falwaysreload: super::super::Foundation::VARIANT_BOOL, pstream: *mut ::core::option::Option<::windows_core::IUnknown>, pbstrmimetype: *mut ::windows_core::BSTR, pfmodified: *mut super::super::Foundation::VARIANT_BOOL, pbstrredirecturl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetLocalCopy(&self, bstrresourceuri: &::windows_core::BSTR, pbstrlocalpath: *mut ::windows_core::BSTR, pbstrmimetype: *mut ::windows_core::BSTR, pbstrredirecturl: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn ReleaseLocalCopy(&self, pbstrlocalpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechResourceLoader {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechResourceLoader_Vtbl { pub const fn new, Impl: ISpeechResourceLoader_Impl, const OFFSET: isize>() -> ISpeechResourceLoader_Vtbl { unsafe extern "system" fn LoadResource, Impl: ISpeechResourceLoader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrresourceuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, falwaysreload: super::super::Foundation::VARIANT_BOOL, pstream: *mut *mut ::core::ffi::c_void, pbstrmimetype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pfmodified: *mut super::super::Foundation::VARIANT_BOOL, pbstrredirecturl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6937,8 +6925,8 @@ impl ISpeechResourceLoader_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechTextSelectionInformation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetActiveOffset(&self, activeoffset: i32) -> ::windows_core::Result<()>; fn ActiveOffset(&self) -> ::windows_core::Result; @@ -6949,9 +6937,9 @@ pub trait ISpeechTextSelectionInformation_Impl: Sized + super::super::System::Co fn SetSelectionLength(&self, selectionlength: i32) -> ::windows_core::Result<()>; fn SelectionLength(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechTextSelectionInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechTextSelectionInformation_Vtbl { pub const fn new, Impl: ISpeechTextSelectionInformation_Impl, const OFFSET: isize>() -> ISpeechTextSelectionInformation_Vtbl { unsafe extern "system" fn SetActiveOffset, Impl: ISpeechTextSelectionInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, activeoffset: i32) -> ::windows_core::HRESULT { @@ -7034,8 +7022,8 @@ impl ISpeechTextSelectionInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechVoice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Status(&self) -> ::windows_core::Result; fn Voice(&self) -> ::windows_core::Result; @@ -7067,12 +7055,12 @@ pub trait ISpeechVoice_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetAudioOutputs(&self, requiredattributes: &::windows_core::BSTR, optionalattributes: &::windows_core::BSTR) -> ::windows_core::Result; fn WaitUntilDone(&self, mstimeout: i32) -> ::windows_core::Result; fn SpeakCompleteEvent(&self) -> ::windows_core::Result; - fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DisplayUI(&self, hwndparent: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn IsUISupported(&self, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn DisplayUI(&self, hwndparent: i32, title: &::windows_core::BSTR, typeofui: &::windows_core::BSTR, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechVoice {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechVoice_Vtbl { pub const fn new, Impl: ISpeechVoice_Impl, const OFFSET: isize>() -> ISpeechVoice_Vtbl { unsafe extern "system" fn Status, Impl: ISpeechVoice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, status: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7333,7 +7321,7 @@ impl ISpeechVoice_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn IsUISupported, Impl: ISpeechVoice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsUISupported, Impl: ISpeechVoice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsUISupported(::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata)) { @@ -7344,7 +7332,7 @@ impl ISpeechVoice_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DisplayUI, Impl: ISpeechVoice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DisplayUI, Impl: ISpeechVoice_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DisplayUI(::core::mem::transmute_copy(&hwndparent), ::core::mem::transmute(&title), ::core::mem::transmute(&typeofui), ::core::mem::transmute_copy(&extradata)).into() @@ -7389,8 +7377,8 @@ impl ISpeechVoice_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechVoiceStatus_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CurrentStreamNumber(&self) -> ::windows_core::Result; fn LastStreamNumberQueued(&self) -> ::windows_core::Result; @@ -7405,9 +7393,9 @@ pub trait ISpeechVoiceStatus_Impl: Sized + super::super::System::Com::IDispatch_ fn PhonemeId(&self) -> ::windows_core::Result; fn VisemeId(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechVoiceStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechVoiceStatus_Vtbl { pub const fn new, Impl: ISpeechVoiceStatus_Impl, const OFFSET: isize>() -> ISpeechVoiceStatus_Vtbl { unsafe extern "system" fn CurrentStreamNumber, Impl: ISpeechVoiceStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, streamnumber: *mut i32) -> ::windows_core::HRESULT { @@ -7562,8 +7550,8 @@ impl ISpeechVoiceStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechWaveFormatEx_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FormatTag(&self) -> ::windows_core::Result; fn SetFormatTag(&self, formattag: i16) -> ::windows_core::Result<()>; @@ -7577,12 +7565,12 @@ pub trait ISpeechWaveFormatEx_Impl: Sized + super::super::System::Com::IDispatch fn SetBlockAlign(&self, blockalign: i16) -> ::windows_core::Result<()>; fn BitsPerSample(&self) -> ::windows_core::Result; fn SetBitsPerSample(&self, bitspersample: i16) -> ::windows_core::Result<()>; - fn ExtraData(&self) -> ::windows_core::Result; - fn SetExtraData(&self, extradata: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ExtraData(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtraData(&self, extradata: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechWaveFormatEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechWaveFormatEx_Vtbl { pub const fn new, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>() -> ISpeechWaveFormatEx_Vtbl { unsafe extern "system" fn FormatTag, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, formattag: *mut i16) -> ::windows_core::HRESULT { @@ -7681,7 +7669,7 @@ impl ISpeechWaveFormatEx_Vtbl { let this = (*this).get_impl(); this.SetBitsPerSample(::core::mem::transmute_copy(&bitspersample)).into() } - unsafe extern "system" fn ExtraData, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, extradata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExtraData, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, extradata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExtraData() { @@ -7692,7 +7680,7 @@ impl ISpeechWaveFormatEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtraData, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, extradata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtraData, Impl: ISpeechWaveFormatEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, extradata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtraData(::core::mem::transmute(&extradata)).into() @@ -7719,15 +7707,15 @@ impl ISpeechWaveFormatEx_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISpeechXMLRecoResult_Impl: Sized + ISpeechRecoResult_Impl { fn GetXMLResult(&self, options: SPXMLRESULTOPTIONS) -> ::windows_core::Result<::windows_core::BSTR>; fn GetXMLErrorInfo(&self, linenumber: *mut i32, scriptline: *mut ::windows_core::BSTR, source: *mut ::windows_core::BSTR, description: *mut ::windows_core::BSTR, resultcode: *mut i32, iserror: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISpeechXMLRecoResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISpeechXMLRecoResult_Vtbl { pub const fn new, Impl: ISpeechXMLRecoResult_Impl, const OFFSET: isize>() -> ISpeechXMLRecoResult_Vtbl { unsafe extern "system" fn GetXMLResult, Impl: ISpeechXMLRecoResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, options: SPXMLRESULTOPTIONS, presult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7756,12 +7744,12 @@ impl ISpeechXMLRecoResult_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _ISpeechRecoContextEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _ISpeechRecoContextEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _ISpeechRecoContextEvents_Vtbl { pub const fn new, Impl: _ISpeechRecoContextEvents_Impl, const OFFSET: isize>() -> _ISpeechRecoContextEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7770,12 +7758,12 @@ impl _ISpeechRecoContextEvents_Vtbl { iid == &<_ISpeechRecoContextEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _ISpeechVoiceEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _ISpeechVoiceEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _ISpeechVoiceEvents_Vtbl { pub const fn new, Impl: _ISpeechVoiceEvents_Impl, const OFFSET: isize>() -> _ISpeechVoiceEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/Speech/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/Speech/mod.rs index 2a75e7d589..8166958f67 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/Speech/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/Speech/mod.rs @@ -511,8 +511,6 @@ impl ISpGrammarBuilder { { (::windows_core::Interface::vtable(self).CreateNewState)(::windows_core::Interface::as_raw(self), hstate.into_param().abi(), phstate).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn AddWordTransition(&self, hfromstate: P0, htostate: P1, psz: P2, pszseparators: P3, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, @@ -522,8 +520,6 @@ impl ISpGrammarBuilder { { (::windows_core::Interface::vtable(self).AddWordTransition)(::windows_core::Interface::as_raw(self), hfromstate.into_param().abi(), htostate.into_param().abi(), psz.into_param().abi(), pszseparators.into_param().abi(), ewordtype, weight, ppropinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn AddRuleTransition(&self, hfromstate: P0, htostate: P1, hrule: P2, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, @@ -552,14 +548,8 @@ pub struct ISpGrammarBuilder_Vtbl { pub GetRule: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszrulename: ::windows_core::PCWSTR, dwruleid: u32, dwattributes: u32, fcreateifnotexist: super::super::Foundation::BOOL, phinitialstate: *mut SPSTATEHANDLE) -> ::windows_core::HRESULT, pub ClearRule: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hstate: SPSTATEHANDLE) -> ::windows_core::HRESULT, pub CreateNewState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hstate: SPSTATEHANDLE, phstate: *mut SPSTATEHANDLE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub AddWordTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hfromstate: SPSTATEHANDLE, htostate: SPSTATEHANDLE, psz: ::windows_core::PCWSTR, pszseparators: ::windows_core::PCWSTR, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddWordTransition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub AddRuleTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hfromstate: SPSTATEHANDLE, htostate: SPSTATEHANDLE, hrule: SPSTATEHANDLE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddRuleTransition: usize, pub AddResource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrulestate: SPSTATEHANDLE, pszresourcename: ::windows_core::PCWSTR, pszresourcevalue: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwreserved: u32) -> ::windows_core::HRESULT, } @@ -1438,8 +1428,6 @@ pub struct ISpPhoneticAlphabetSelection_Vtbl { ::windows_core::imp::com_interface!(ISpPhrase, ISpPhrase_Vtbl, 0x1a5c0354_b621_4b5a_8791_d306ed379e53); ::windows_core::imp::interface_hierarchy!(ISpPhrase, ::windows_core::IUnknown); impl ISpPhrase { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -1462,10 +1450,7 @@ impl ISpPhrase { #[doc(hidden)] pub struct ISpPhrase_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetPhrase: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPhrase: usize, pub GetSerializedPhrase: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows_core::HRESULT, pub GetText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut ::windows_core::PWSTR, pbdisplayattributes: *mut u8) -> ::windows_core::HRESULT, pub Discard: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwvaluetypes: u32) -> ::windows_core::HRESULT, @@ -1473,8 +1458,6 @@ pub struct ISpPhrase_Vtbl { ::windows_core::imp::com_interface!(ISpPhrase2, ISpPhrase2_Vtbl, 0xf264da52_e457_4696_b856_a737b717af79); ::windows_core::imp::interface_hierarchy!(ISpPhrase2, ::windows_core::IUnknown, ISpPhrase); impl ISpPhrase2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -1519,8 +1502,6 @@ pub struct ISpPhrase2_Vtbl { ::windows_core::imp::com_interface!(ISpPhraseAlt, ISpPhraseAlt_Vtbl, 0x8fcebc98_4e49_4067_9c6c_d86a0e092e3d); ::windows_core::imp::interface_hierarchy!(ISpPhraseAlt, ::windows_core::IUnknown, ISpPhrase); impl ISpPhraseAlt { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -1793,8 +1774,6 @@ impl ISpRecoGrammar { { (::windows_core::Interface::vtable(self).base__.CreateNewState)(::windows_core::Interface::as_raw(self), hstate.into_param().abi(), phstate).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn AddWordTransition(&self, hfromstate: P0, htostate: P1, psz: P2, pszseparators: P3, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, @@ -1804,8 +1783,6 @@ impl ISpRecoGrammar { { (::windows_core::Interface::vtable(self).base__.AddWordTransition)(::windows_core::Interface::as_raw(self), hfromstate.into_param().abi(), htostate.into_param().abi(), psz.into_param().abi(), pszseparators.into_param().abi(), ewordtype, weight, ppropinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn AddRuleTransition(&self, hfromstate: P0, htostate: P1, hrule: P2, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, @@ -2010,8 +1987,6 @@ pub struct ISpRecoGrammar2_Vtbl { ::windows_core::imp::com_interface!(ISpRecoResult, ISpRecoResult_Vtbl, 0x20b053be_e235_43cd_9a2a_8d17a48b7842); ::windows_core::imp::interface_hierarchy!(ISpRecoResult, ::windows_core::IUnknown, ISpPhrase); impl ISpRecoResult { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -2078,8 +2053,6 @@ pub struct ISpRecoResult_Vtbl { ::windows_core::imp::com_interface!(ISpRecoResult2, ISpRecoResult2_Vtbl, 0x27cac6c4_88f2_41f2_8817_0c95e59f1e6e); ::windows_core::imp::interface_hierarchy!(ISpRecoResult2, ::windows_core::IUnknown, ISpPhrase, ISpRecoResult); impl ISpRecoResult2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -3073,8 +3046,6 @@ pub struct ISpVoice_Vtbl { ::windows_core::imp::com_interface!(ISpXMLRecoResult, ISpXMLRecoResult_Vtbl, 0xae39362b_45a8_4074_9b9e_ccf49aa2d0b6); ::windows_core::imp::interface_hierarchy!(ISpXMLRecoResult, ::windows_core::IUnknown, ISpPhrase, ISpRecoResult); impl ISpXMLRecoResult { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetPhrase(&self) -> ::windows_core::Result<*mut SPPHRASE> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetPhrase)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -3158,22 +3129,22 @@ impl ISpeechAudio { { (::windows_core::Interface::vtable(self).base__.putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3368,15 +3339,11 @@ impl ISpeechAudioStatus { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).State)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CurrentSeekPosition(&self) -> ::windows_core::Result { + pub unsafe fn CurrentSeekPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CurrentSeekPosition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CurrentDevicePosition(&self) -> ::windows_core::Result { + pub unsafe fn CurrentDevicePosition(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CurrentDevicePosition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3389,14 +3356,8 @@ pub struct ISpeechAudioStatus_Vtbl { pub FreeBufferSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, freebufferspace: *mut i32) -> ::windows_core::HRESULT, pub NonBlockingIO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nonblockingio: *mut i32) -> ::windows_core::HRESULT, pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, state: *mut SpeechAudioState) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CurrentSeekPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, currentseekposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CurrentSeekPosition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CurrentDevicePosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, currentdeviceposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CurrentDevicePosition: usize, + pub CurrentSeekPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, currentseekposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CurrentDevicePosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, currentdeviceposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3423,22 +3384,22 @@ impl ISpeechBaseStream { { (::windows_core::Interface::vtable(self).putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3454,18 +3415,9 @@ pub struct ISpeechBaseStream_Vtbl { pub putref_Format: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, audioformat: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_Format: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Read: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buffer: super::super::System::Variant::VARIANT, byteswritten: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Write: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Seek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType, newposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Seek: usize, + pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buffer: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::HRESULT, + pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buffer: ::std::mem::MaybeUninit<::windows_core::VARIANT>, byteswritten: *mut i32) -> ::windows_core::HRESULT, + pub Seek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, position: ::std::mem::MaybeUninit<::windows_core::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3492,22 +3444,22 @@ impl ISpeechCustomStream { { (::windows_core::Interface::vtable(self).base__.putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } pub unsafe fn BaseStream(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -3539,17 +3491,14 @@ pub struct ISpeechCustomStream_Vtbl { ::windows_core::imp::interface_hierarchy!(ISpeechDataKey, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISpeechDataKey { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBinaryValue(&self, valuename: P0, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetBinaryValue(&self, valuename: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetBinaryValue)(::windows_core::Interface::as_raw(self), valuename.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).SetBinaryValue)(::windows_core::Interface::as_raw(self), valuename.into_param().abi(), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetBinaryValue(&self, valuename: P0) -> ::windows_core::Result + pub unsafe fn GetBinaryValue(&self, valuename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3627,14 +3576,8 @@ impl ISpeechDataKey { #[doc(hidden)] pub struct ISpeechDataKey_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBinaryValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetBinaryValue: usize, + pub SetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetStringValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetStringValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetLongValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuename: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: i32) -> ::windows_core::HRESULT, @@ -3677,22 +3620,22 @@ impl ISpeechFileStream { { (::windows_core::Interface::vtable(self).base__.putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } pub unsafe fn Open(&self, filename: P0, filemode: SpeechStreamFileMode, doevents: P1) -> ::windows_core::Result<()> where @@ -3801,35 +3744,35 @@ impl ISpeechGrammarRuleState { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Transitions)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddWordTransition(&self, deststate: P0, words: P1, separators: P2, r#type: SpeechGrammarWordType, propertyname: P3, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn AddWordTransition(&self, deststate: P0, words: P1, separators: P2, r#type: SpeechGrammarWordType, propertyname: P3, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, P3: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddWordTransition)(::windows_core::Interface::as_raw(self), deststate.into_param().abi(), words.into_param().abi(), separators.into_param().abi(), r#type, propertyname.into_param().abi(), propertyid, propertyvalue, weight).ok() + (::windows_core::Interface::vtable(self).AddWordTransition)(::windows_core::Interface::as_raw(self), deststate.into_param().abi(), words.into_param().abi(), separators.into_param().abi(), r#type, propertyname.into_param().abi(), propertyid, ::core::mem::transmute(propertyvalue), weight).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddRuleTransition(&self, destinationstate: P0, rule: P1, propertyname: P2, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn AddRuleTransition(&self, destinationstate: P0, rule: P1, propertyname: P2, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddRuleTransition)(::windows_core::Interface::as_raw(self), destinationstate.into_param().abi(), rule.into_param().abi(), propertyname.into_param().abi(), propertyid, propertyvalue, weight).ok() + (::windows_core::Interface::vtable(self).AddRuleTransition)(::windows_core::Interface::as_raw(self), destinationstate.into_param().abi(), rule.into_param().abi(), propertyname.into_param().abi(), propertyid, ::core::mem::transmute(propertyvalue), weight).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddSpecialTransition(&self, destinationstate: P0, r#type: SpeechSpecialTransitionType, propertyname: P1, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn AddSpecialTransition(&self, destinationstate: P0, r#type: SpeechSpecialTransitionType, propertyname: P1, propertyid: i32, propertyvalue: *const ::windows_core::VARIANT, weight: f32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddSpecialTransition)(::windows_core::Interface::as_raw(self), destinationstate.into_param().abi(), r#type, propertyname.into_param().abi(), propertyid, propertyvalue, weight).ok() + (::windows_core::Interface::vtable(self).AddSpecialTransition)(::windows_core::Interface::as_raw(self), destinationstate.into_param().abi(), r#type, propertyname.into_param().abi(), propertyid, ::core::mem::transmute(propertyvalue), weight).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3845,17 +3788,17 @@ pub struct ISpeechGrammarRuleState_Vtbl { pub Transitions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transitions: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Transitions: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddWordTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, deststate: *mut ::core::ffi::c_void, words: ::std::mem::MaybeUninit<::windows_core::BSTR>, separators: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: SpeechGrammarWordType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub AddWordTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, deststate: *mut ::core::ffi::c_void, words: ::std::mem::MaybeUninit<::windows_core::BSTR>, separators: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: SpeechGrammarWordType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] AddWordTransition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddRuleTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, rule: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub AddRuleTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, rule: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] AddRuleTransition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddSpecialTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, r#type: SpeechSpecialTransitionType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const super::super::System::Variant::VARIANT, weight: f32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub AddSpecialTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationstate: *mut ::core::ffi::c_void, r#type: SpeechSpecialTransitionType, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyid: i32, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, weight: f32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] AddSpecialTransition: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3883,9 +3826,7 @@ impl ISpeechGrammarRuleStateTransition { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Rule)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Weight(&self) -> ::windows_core::Result { + pub unsafe fn Weight(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Weight)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3897,9 +3838,7 @@ impl ISpeechGrammarRuleStateTransition { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PropertyId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PropertyValue(&self) -> ::windows_core::Result { + pub unsafe fn PropertyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PropertyValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3921,16 +3860,10 @@ pub struct ISpeechGrammarRuleStateTransition_Vtbl { pub Rule: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Rule: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Weight: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, weight: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Weight: usize, + pub Weight: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, weight: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PropertyName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PropertyId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PropertyValue: usize, + pub PropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub NextState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nextstate: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3989,11 +3922,14 @@ impl ISpeechGrammarRules { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindRule(&self, rulenameorid: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn FindRule(&self, rulenameorid: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindRule)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rulenameorid), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindRule)(::windows_core::Interface::as_raw(self), rulenameorid.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4021,10 +3957,8 @@ impl ISpeechGrammarRules { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CommitAndSave(&self, errortext: *mut ::windows_core::BSTR, savestream: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CommitAndSave)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(errortext), savestream).ok() + pub unsafe fn CommitAndSave(&self, errortext: *mut ::windows_core::BSTR, savestream: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).CommitAndSave)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(errortext), ::core::mem::transmute(savestream)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4033,9 +3967,9 @@ impl ISpeechGrammarRules { pub struct ISpeechGrammarRules_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindRule: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulenameorid: super::super::System::Variant::VARIANT, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub FindRule: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulenameorid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] FindRule: usize, #[cfg(feature = "Win32_System_Com")] pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, rule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4048,10 +3982,7 @@ pub struct ISpeechGrammarRules_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Add: usize, pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CommitAndSave: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, errortext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, savestream: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CommitAndSave: usize, + pub CommitAndSave: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, errortext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, savestream: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4080,13 +4011,11 @@ impl ISpeechLexicon { { (::windows_core::Interface::vtable(self).AddPronunciation)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, bstrpronunciation.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPronunciationByPhoneIds(&self, bstrword: P0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPronunciationByPhoneIds(&self, bstrword: P0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddPronunciationByPhoneIds)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, phoneids).ok() + (::windows_core::Interface::vtable(self).AddPronunciationByPhoneIds)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, ::core::mem::transmute(phoneids)).ok() } pub unsafe fn RemovePronunciation(&self, bstrword: P0, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: P1) -> ::windows_core::Result<()> where @@ -4095,13 +4024,11 @@ impl ISpeechLexicon { { (::windows_core::Interface::vtable(self).RemovePronunciation)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, bstrpronunciation.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemovePronunciationByPhoneIds(&self, bstrword: P0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn RemovePronunciationByPhoneIds(&self, bstrword: P0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).RemovePronunciationByPhoneIds)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, phoneids).ok() + (::windows_core::Interface::vtable(self).RemovePronunciationByPhoneIds)(::windows_core::Interface::as_raw(self), bstrword.into_param().abi(), langid, partofspeech, ::core::mem::transmute(phoneids)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4129,15 +4056,9 @@ pub struct ISpeechLexicon_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] GetWords: usize, pub AddPronunciation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPronunciationByPhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPronunciationByPhoneIds: usize, + pub AddPronunciationByPhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RemovePronunciation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemovePronunciationByPhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemovePronunciationByPhoneIds: usize, + pub RemovePronunciationByPhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetPronunciations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrword: ::std::mem::MaybeUninit<::windows_core::BSTR>, langid: i32, typeflags: SpeechLexiconType, pppronunciations: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4170,9 +4091,7 @@ impl ISpeechLexiconPronunciation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PartOfSpeech)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PhoneIds(&self) -> ::windows_core::Result { + pub unsafe fn PhoneIds(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PhoneIds)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4189,10 +4108,7 @@ pub struct ISpeechLexiconPronunciation_Vtbl { pub Type: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lexicontype: *mut SpeechLexiconType) -> ::windows_core::HRESULT, pub LangId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, langid: *mut i32) -> ::windows_core::HRESULT, pub PartOfSpeech: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, partofspeech: *mut SpeechPartOfSpeech) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phoneids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PhoneIds: usize, + pub PhoneIds: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phoneids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Symbolic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, symbolic: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -4339,22 +4255,22 @@ impl ISpeechMMSysAudio { { (::windows_core::Interface::vtable(self).base__.base__.putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4450,31 +4366,30 @@ impl ISpeechMemoryStream { { (::windows_core::Interface::vtable(self).base__.putref_Format)(::windows_core::Interface::as_raw(self), audioformat.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, buffer: *mut super::super::System::Variant::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), buffer, numberofbytes, bytesread).ok() + pub unsafe fn Read(&self, buffer: *mut ::windows_core::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), numberofbytes, bytesread).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, buffer: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Write(&self, buffer: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buffer), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), buffer.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Seek(&self, position: super::super::System::Variant::VARIANT, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result { + pub unsafe fn Seek(&self, position: P0, origin: SpeechStreamSeekPositionType) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(position), origin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Seek)(::windows_core::Interface::as_raw(self), position.into_param().abi(), origin, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetData(&self, data: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetData)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(data)).ok() + pub unsafe fn SetData(&self, data: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetData)(::windows_core::Interface::as_raw(self), data.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetData(&self) -> ::windows_core::Result { + pub unsafe fn GetData(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4484,14 +4399,8 @@ impl ISpeechMemoryStream { #[doc(hidden)] pub struct ISpeechMemoryStream_Vtbl { pub base__: ISpeechBaseStream_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetData: usize, + pub SetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4569,25 +4478,21 @@ impl ISpeechObjectToken { { (::windows_core::Interface::vtable(self).RemoveStorageFileName)(::windows_core::Interface::as_raw(self), objectstorageclsid.into_param().abi(), keyname.into_param().abi(), deletefile.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const super::super::System::Variant::VARIANT, object: P1) -> ::windows_core::Result + pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const ::windows_core::VARIANT, object: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), extradata, object.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), object.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DisplayUI(&self, hwnd: i32, title: P0, typeofui: P1, extradata: *const super::super::System::Variant::VARIANT, object: P2) -> ::windows_core::Result<()> + pub unsafe fn DisplayUI(&self, hwnd: i32, title: P0, typeofui: P1, extradata: *const ::windows_core::VARIANT, object: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::IUnknown>, { - (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), typeofui.into_param().abi(), extradata, object.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata), object.into_param().abi()).ok() } pub unsafe fn MatchesAttributes(&self, attributes: P0) -> ::windows_core::Result where @@ -4618,14 +4523,8 @@ pub struct ISpeechObjectToken_Vtbl { pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectstorageclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetStorageFileName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectstorageclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, keyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>, folder: SpeechTokenShellFolder, filepath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RemoveStorageFileName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectstorageclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, keyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, deletefile: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, object: *mut ::core::ffi::c_void, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsUISupported: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, object: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DisplayUI: usize, + pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut ::core::ffi::c_void, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub MatchesAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributes: ::std::mem::MaybeUninit<::windows_core::BSTR>, matches: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -4751,20 +4650,19 @@ impl ISpeechPhoneConverter { pub unsafe fn SetLanguageId(&self, languageid: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetLanguageId)(::windows_core::Interface::as_raw(self), languageid).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PhoneToId(&self, phonemes: P0) -> ::windows_core::Result + pub unsafe fn PhoneToId(&self, phonemes: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PhoneToId)(::windows_core::Interface::as_raw(self), phonemes.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IdToPhone(&self, idarray: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn IdToPhone(&self, idarray: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IdToPhone)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(idarray), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IdToPhone)(::windows_core::Interface::as_raw(self), idarray.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4774,14 +4672,8 @@ pub struct ISpeechPhoneConverter_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub LanguageId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, languageid: *mut i32) -> ::windows_core::HRESULT, pub SetLanguageId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, languageid: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PhoneToId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phonemes: ::std::mem::MaybeUninit<::windows_core::BSTR>, idarray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PhoneToId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IdToPhone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, idarray: super::super::System::Variant::VARIANT, phonemes: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IdToPhone: usize, + pub PhoneToId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phonemes: ::std::mem::MaybeUninit<::windows_core::BSTR>, idarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub IdToPhone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, idarray: ::std::mem::MaybeUninit<::windows_core::VARIANT>, phonemes: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4916,9 +4808,7 @@ impl ISpeechPhraseElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LexicalForm)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Pronunciation(&self) -> ::windows_core::Result { + pub unsafe fn Pronunciation(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Pronunciation)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4952,10 +4842,7 @@ pub struct ISpeechPhraseElement_Vtbl { pub RetainedSizeBytes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retainedsizebytes: *mut i32) -> ::windows_core::HRESULT, pub DisplayText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, displaytext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LexicalForm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lexicalform: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Pronunciation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pronunciation: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Pronunciation: usize, + pub Pronunciation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pronunciation: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DisplayAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, displayattributes: *mut SpeechDisplayAttributes) -> ::windows_core::HRESULT, pub RequiredConfidence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requiredconfidence: *mut SpeechEngineConfidence) -> ::windows_core::HRESULT, pub ActualConfidence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, actualconfidence: *mut SpeechEngineConfidence) -> ::windows_core::HRESULT, @@ -5014,21 +4901,15 @@ impl ISpeechPhraseInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LanguageId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GrammarId(&self) -> ::windows_core::Result { + pub unsafe fn GrammarId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GrammarId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StartTime(&self) -> ::windows_core::Result { + pub unsafe fn StartTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StartTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AudioStreamPosition(&self) -> ::windows_core::Result { + pub unsafe fn AudioStreamPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AudioStreamPosition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5072,15 +4953,11 @@ impl ISpeechPhraseInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EngineId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnginePrivateData(&self) -> ::windows_core::Result { + pub unsafe fn EnginePrivateData(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnginePrivateData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result { + pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SaveToMemory)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5105,18 +4982,9 @@ impl ISpeechPhraseInfo { pub struct ISpeechPhraseInfo_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub LanguageId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, languageid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GrammarId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammarid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GrammarId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, starttime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StartTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AudioStreamPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, audiostreamposition: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AudioStreamPosition: usize, + pub GrammarId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammarid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub StartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, starttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AudioStreamPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, audiostreamposition: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AudioSizeBytes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paudiosizebytes: *mut i32) -> ::windows_core::HRESULT, pub RetainedSizeBytes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retainedsizebytes: *mut i32) -> ::windows_core::HRESULT, pub AudioSizeTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, audiosizetime: *mut i32) -> ::windows_core::HRESULT, @@ -5137,14 +5005,8 @@ pub struct ISpeechPhraseInfo_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Replacements: usize, pub EngineId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, engineidguid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnginePrivateData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, privatedata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnginePrivateData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phraseblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SaveToMemory: usize, + pub EnginePrivateData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, privatedata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phraseblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, startelement: i32, elements: i32, usereplacements: super::super::Foundation::VARIANT_BOOL, text: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetDisplayAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, startelement: i32, elements: i32, usereplacements: super::super::Foundation::VARIANT_BOOL, displayattributes: *mut SpeechDisplayAttributes) -> ::windows_core::HRESULT, } @@ -5159,11 +5021,11 @@ pub struct ISpeechPhraseInfo_Vtbl { ::windows_core::imp::interface_hierarchy!(ISpeechPhraseInfoBuilder, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISpeechPhraseInfoBuilder { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestorePhraseFromMemory(&self, phraseinmemory: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestorePhraseFromMemory(&self, phraseinmemory: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).RestorePhraseFromMemory)(::windows_core::Interface::as_raw(self), phraseinmemory, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).RestorePhraseFromMemory)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(phraseinmemory), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -5171,9 +5033,9 @@ impl ISpeechPhraseInfoBuilder { #[doc(hidden)] pub struct ISpeechPhraseInfoBuilder_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RestorePhraseFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phraseinmemory: *const super::super::System::Variant::VARIANT, phraseinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RestorePhraseFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phraseinmemory: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, phraseinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RestorePhraseFromMemory: usize, } #[cfg(feature = "Win32_System_Com")] @@ -5233,9 +5095,7 @@ impl ISpeechPhraseProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5275,10 +5135,7 @@ pub struct ISpeechPhraseProperty_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub FirstElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, firstelement: *mut i32) -> ::windows_core::HRESULT, pub NumberOfElements: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, numberofelements: *mut i32) -> ::windows_core::HRESULT, pub EngineConfidence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, confidence: *mut f32) -> ::windows_core::HRESULT, @@ -5578,22 +5435,27 @@ impl ISpeechRecoContext { pub unsafe fn Resume(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Resume)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateGrammar(&self, grammarid: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateGrammar(&self, grammarid: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateGrammar)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(grammarid), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateGrammar)(::windows_core::Interface::as_raw(self), grammarid.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateResultFromMemory(&self, resultblock: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateResultFromMemory(&self, resultblock: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateResultFromMemory)(::windows_core::Interface::as_raw(self), resultblock, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateResultFromMemory)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resultblock), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Bookmark(&self, options: SpeechBookmarkOptions, streampos: super::super::System::Variant::VARIANT, bookmarkid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Bookmark)(::windows_core::Interface::as_raw(self), options, ::core::mem::transmute(streampos), ::core::mem::transmute(bookmarkid)).ok() + pub unsafe fn Bookmark(&self, options: SpeechBookmarkOptions, streampos: P0, bookmarkid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Bookmark)(::windows_core::Interface::as_raw(self), options, streampos.into_param().abi(), bookmarkid.into_param().abi()).ok() } pub unsafe fn SetAdaptationData(&self, adaptationstring: P0) -> ::windows_core::Result<()> where @@ -5643,18 +5505,15 @@ pub struct ISpeechRecoContext_Vtbl { RetainedAudioFormat: usize, pub Pause: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Resume: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateGrammar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammarid: super::super::System::Variant::VARIANT, grammar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateGrammar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammarid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, grammar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateGrammar: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateResultFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *const super::super::System::Variant::VARIANT, result: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateResultFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, result: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateResultFromMemory: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Bookmark: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: SpeechBookmarkOptions, streampos: super::super::System::Variant::VARIANT, bookmarkid: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Bookmark: usize, + pub Bookmark: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: SpeechBookmarkOptions, streampos: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bookmarkid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetAdaptationData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, adaptationstring: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5668,9 +5527,7 @@ pub struct ISpeechRecoContext_Vtbl { ::windows_core::imp::interface_hierarchy!(ISpeechRecoGrammar, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISpeechRecoGrammar { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Id(&self) -> ::windows_core::Result { + pub unsafe fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5709,24 +5566,26 @@ impl ISpeechRecoGrammar { { (::windows_core::Interface::vtable(self).CmdLoadFromObject)(::windows_core::Interface::as_raw(self), classid.into_param().abi(), grammarname.into_param().abi(), loadoption).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CmdLoadFromResource(&self, hmodule: i32, resourcename: super::super::System::Variant::VARIANT, resourcetype: super::super::System::Variant::VARIANT, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CmdLoadFromResource)(::windows_core::Interface::as_raw(self), hmodule, ::core::mem::transmute(resourcename), ::core::mem::transmute(resourcetype), languageid, loadoption).ok() + pub unsafe fn CmdLoadFromResource(&self, hmodule: i32, resourcename: P0, resourcetype: P1, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).CmdLoadFromResource)(::windows_core::Interface::as_raw(self), hmodule, resourcename.into_param().abi(), resourcetype.into_param().abi(), languageid, loadoption).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CmdLoadFromMemory(&self, grammardata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CmdLoadFromMemory)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(grammardata), loadoption).ok() + pub unsafe fn CmdLoadFromMemory(&self, grammardata: P0, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).CmdLoadFromMemory)(::windows_core::Interface::as_raw(self), grammardata.into_param().abi(), loadoption).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CmdLoadFromProprietaryGrammar(&self, proprietaryguid: P0, proprietarystring: P1, proprietarydata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> + pub unsafe fn CmdLoadFromProprietaryGrammar(&self, proprietaryguid: P0, proprietarystring: P1, proprietarydata: P2, loadoption: SpeechLoadOption) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).CmdLoadFromProprietaryGrammar)(::windows_core::Interface::as_raw(self), proprietaryguid.into_param().abi(), proprietarystring.into_param().abi(), ::core::mem::transmute(proprietarydata), loadoption).ok() + (::windows_core::Interface::vtable(self).CmdLoadFromProprietaryGrammar)(::windows_core::Interface::as_raw(self), proprietaryguid.into_param().abi(), proprietarystring.into_param().abi(), proprietarydata.into_param().abi(), loadoption).ok() } pub unsafe fn CmdSetRuleState(&self, name: P0, state: SpeechRuleState) -> ::windows_core::Result<()> where @@ -5779,10 +5638,7 @@ impl ISpeechRecoGrammar { #[doc(hidden)] pub struct ISpeechRecoGrammar_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Id: usize, + pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub RecoContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, recocontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -5796,18 +5652,9 @@ pub struct ISpeechRecoGrammar_Vtbl { pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newlanguage: i32) -> ::windows_core::HRESULT, pub CmdLoadFromFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, pub CmdLoadFromObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, classid: ::std::mem::MaybeUninit<::windows_core::BSTR>, grammarname: ::std::mem::MaybeUninit<::windows_core::BSTR>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CmdLoadFromResource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hmodule: i32, resourcename: super::super::System::Variant::VARIANT, resourcetype: super::super::System::Variant::VARIANT, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CmdLoadFromResource: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CmdLoadFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammardata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CmdLoadFromMemory: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CmdLoadFromProprietaryGrammar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proprietaryguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarystring: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarydata: super::super::System::Variant::VARIANT, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CmdLoadFromProprietaryGrammar: usize, + pub CmdLoadFromResource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hmodule: i32, resourcename: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resourcetype: ::std::mem::MaybeUninit<::windows_core::VARIANT>, languageid: i32, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, + pub CmdLoadFromMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, grammardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, + pub CmdLoadFromProprietaryGrammar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proprietaryguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarystring: ::std::mem::MaybeUninit<::windows_core::BSTR>, proprietarydata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, pub CmdSetRuleState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, state: SpeechRuleState) -> ::windows_core::HRESULT, pub CmdSetRuleIdState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ruleid: i32, state: SpeechRuleState) -> ::windows_core::HRESULT, pub DictationLoad: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, topicname: ::std::mem::MaybeUninit<::windows_core::BSTR>, loadoption: SpeechLoadOption) -> ::windows_core::HRESULT, @@ -5882,9 +5729,7 @@ impl ISpeechRecoResult { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SpeakAudio)(::windows_core::Interface::as_raw(self), startelement, elements, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result { + pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SaveToMemory)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5926,10 +5771,7 @@ pub struct ISpeechRecoResult_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Audio: usize, pub SpeakAudio: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SaveToMemory: usize, + pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DiscardResultInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuetypes: SpeechDiscardType) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5991,9 +5833,7 @@ impl ISpeechRecoResult2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SpeakAudio)(::windows_core::Interface::as_raw(self), startelement, elements, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result { + pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SaveToMemory)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6074,9 +5914,7 @@ impl ISpeechRecoResultDispatch { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SpeakAudio)(::windows_core::Interface::as_raw(self), startelement, elements, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result { + pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SaveToMemory)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6132,10 +5970,7 @@ pub struct ISpeechRecoResultDispatch_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Audio: usize, pub SpeakAudio: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SaveToMemory: usize, + pub SaveToMemory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resultblock: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DiscardResultInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, valuetypes: SpeechDiscardType) -> ::windows_core::HRESULT, pub GetXMLResult: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: SPXMLRESULTOPTIONS, presult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetXMLErrorInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, linenumber: *mut i32, scriptline: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, source: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, description: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, resultcode: *mut ::windows_core::HRESULT, iserror: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -6152,15 +5987,11 @@ pub struct ISpeechRecoResultDispatch_Vtbl { ::windows_core::imp::interface_hierarchy!(ISpeechRecoResultTimes, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISpeechRecoResultTimes { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StreamTime(&self) -> ::windows_core::Result { + pub unsafe fn StreamTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StreamTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Length(&self) -> ::windows_core::Result { + pub unsafe fn Length(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Length)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6168,9 +5999,7 @@ impl ISpeechRecoResultTimes { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TickCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OffsetFromStart(&self) -> ::windows_core::Result { + pub unsafe fn OffsetFromStart(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).OffsetFromStart)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6180,19 +6009,10 @@ impl ISpeechRecoResultTimes { #[doc(hidden)] pub struct ISpeechRecoResultTimes_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StreamTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, time: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StreamTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Length: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, length: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Length: usize, + pub StreamTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, time: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Length: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, length: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub TickCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tickcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OffsetFromStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, offsetfromstart: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OffsetFromStart: usize, + pub OffsetFromStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, offsetfromstart: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6288,10 +6108,11 @@ impl ISpeechRecognizer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Profile)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EmulateRecognition(&self, textelements: super::super::System::Variant::VARIANT, elementdisplayattributes: *const super::super::System::Variant::VARIANT, languageid: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EmulateRecognition)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(textelements), elementdisplayattributes, languageid).ok() + pub unsafe fn EmulateRecognition(&self, textelements: P0, elementdisplayattributes: *const ::windows_core::VARIANT, languageid: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).EmulateRecognition)(::windows_core::Interface::as_raw(self), textelements.into_param().abi(), ::core::mem::transmute(elementdisplayattributes), languageid).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6332,23 +6153,19 @@ impl ISpeechRecognizer { { (::windows_core::Interface::vtable(self).GetPropertyString)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value), supported).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), extradata, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DisplayUI(&self, hwndparent: i32, title: P0, typeofui: P1, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DisplayUI(&self, hwndparent: i32, title: P0, typeofui: P1, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwndparent, title.into_param().abi(), typeofui.into_param().abi(), extradata).ok() + (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwndparent, title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6427,10 +6244,7 @@ pub struct ISpeechRecognizer_Vtbl { pub Profile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profile: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Profile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EmulateRecognition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, textelements: super::super::System::Variant::VARIANT, elementdisplayattributes: *const super::super::System::Variant::VARIANT, languageid: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EmulateRecognition: usize, + pub EmulateRecognition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, textelements: ::std::mem::MaybeUninit<::windows_core::VARIANT>, elementdisplayattributes: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, languageid: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateRecoContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -6443,14 +6257,8 @@ pub struct ISpeechRecognizer_Vtbl { pub GetPropertyNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut i32, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetPropertyString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::BSTR>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub GetPropertyString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsUISupported: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DisplayUI: usize, + pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetRecognizers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, requiredattributes: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionalattributes: ::std::mem::MaybeUninit<::windows_core::BSTR>, objecttokens: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -6481,9 +6289,7 @@ impl ISpeechRecognizerStatus { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AudioStatus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CurrentStreamPosition(&self) -> ::windows_core::Result { + pub unsafe fn CurrentStreamPosition(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CurrentStreamPosition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6499,9 +6305,7 @@ impl ISpeechRecognizerStatus { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ClsidEngine)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SupportedLanguages(&self) -> ::windows_core::Result { + pub unsafe fn SupportedLanguages(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SupportedLanguages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6515,17 +6319,11 @@ pub struct ISpeechRecognizerStatus_Vtbl { pub AudioStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, audiostatus: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AudioStatus: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CurrentStreamPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcurrentstreampos: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CurrentStreamPosition: usize, + pub CurrentStreamPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcurrentstreampos: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub CurrentStreamNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, streamnumber: *mut i32) -> ::windows_core::HRESULT, pub NumberOfActiveRules: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, numberofactiverules: *mut i32) -> ::windows_core::HRESULT, pub ClsidEngine: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, clsidengine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SupportedLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, supportedlanguages: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SupportedLanguages: usize, + pub SupportedLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, supportedlanguages: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6789,23 +6587,19 @@ impl ISpeechVoice { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SpeakCompleteEvent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn IsUISupported(&self, typeofui: P0, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), extradata, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IsUISupported)(::windows_core::Interface::as_raw(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DisplayUI(&self, hwndparent: i32, title: P0, typeofui: P1, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DisplayUI(&self, hwndparent: i32, title: P0, typeofui: P1, extradata: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwndparent, title.into_param().abi(), typeofui.into_param().abi(), extradata).ok() + (::windows_core::Interface::vtable(self).DisplayUI)(::windows_core::Interface::as_raw(self), hwndparent, title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6873,14 +6667,8 @@ pub struct ISpeechVoice_Vtbl { GetAudioOutputs: usize, pub WaitUntilDone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mstimeout: i32, done: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SpeakCompleteEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, handle: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsUISupported: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DisplayUI: usize, + pub IsUISupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, supported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub DisplayUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, typeofui: ::std::mem::MaybeUninit<::windows_core::BSTR>, extradata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7013,16 +6801,15 @@ impl ISpeechWaveFormatEx { pub unsafe fn SetBitsPerSample(&self, bitspersample: i16) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetBitsPerSample)(::windows_core::Interface::as_raw(self), bitspersample).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExtraData(&self) -> ::windows_core::Result { + pub unsafe fn ExtraData(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ExtraData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtraData(&self, extradata: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetExtraData)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(extradata)).ok() + pub unsafe fn SetExtraData(&self, extradata: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetExtraData)(::windows_core::Interface::as_raw(self), extradata.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -7042,14 +6829,8 @@ pub struct ISpeechWaveFormatEx_Vtbl { pub SetBlockAlign: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, blockalign: i16) -> ::windows_core::HRESULT, pub BitsPerSample: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bitspersample: *mut i16) -> ::windows_core::HRESULT, pub SetBitsPerSample: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bitspersample: i16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExtraData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, extradata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExtraData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtraData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, extradata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtraData: usize, + pub ExtraData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, extradata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtraData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, extradata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7110,9 +6891,7 @@ impl ISpeechXMLRecoResult { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SpeakAudio)(::windows_core::Interface::as_raw(self), startelement, elements, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result { + pub unsafe fn SaveToMemory(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SaveToMemory)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -9967,40 +9746,31 @@ impl ::core::default::Default for SPNORMALIZATIONLIST { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct SPPHRASE { pub Base: SPPHRASE_50, pub pSML: ::windows_core::PWSTR, pub pSemanticErrorInfo: *mut SPSEMANTICERRORINFO, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for SPPHRASE {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPHRASE { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for SPPHRASE { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("SPPHRASE").field("Base", &self.Base).field("pSML", &self.pSML).field("pSemanticErrorInfo", &self.pSemanticErrorInfo).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SPPHRASE { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for SPPHRASE { fn eq(&self, other: &Self) -> bool { self.Base == other.Base && self.pSML == other.pSML && self.pSemanticErrorInfo == other.pSemanticErrorInfo } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for SPPHRASE {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for SPPHRASE { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -10064,13 +9834,11 @@ impl ::core::default::Default for SPPHRASEELEMENT { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct SPPHRASEPROPERTY { pub pszName: ::windows_core::PCWSTR, pub Anonymous: SPPHRASEPROPERTY_0, pub pszValue: ::windows_core::PCWSTR, - pub vValue: super::super::System::Variant::VARIANT, + pub vValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub ulFirstElement: u32, pub ulCountOfElements: u32, pub pNextSibling: *const SPPHRASEPROPERTY, @@ -10078,82 +9846,64 @@ pub struct SPPHRASEPROPERTY { pub SREngineConfidence: f32, pub Confidence: i8, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPHRASEPROPERTY { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SPPHRASEPROPERTY { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for SPPHRASEPROPERTY { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub union SPPHRASEPROPERTY_0 { pub ulId: u32, pub Anonymous: SPPHRASEPROPERTY_0_0, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for SPPHRASEPROPERTY_0 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPHRASEPROPERTY_0 { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SPPHRASEPROPERTY_0 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for SPPHRASEPROPERTY_0 { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct SPPHRASEPROPERTY_0_0 { pub bType: u8, pub bReserved: u8, pub usArrayIndex: u16, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for SPPHRASEPROPERTY_0_0 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPHRASEPROPERTY_0_0 { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for SPPHRASEPROPERTY_0_0 { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("SPPHRASEPROPERTY_0_0").field("bType", &self.bType).field("bReserved", &self.bReserved).field("usArrayIndex", &self.usArrayIndex).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SPPHRASEPROPERTY_0_0 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for SPPHRASEPROPERTY_0_0 { fn eq(&self, other: &Self) -> bool { self.bType == other.bType && self.bReserved == other.bReserved && self.usArrayIndex == other.usArrayIndex } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for SPPHRASEPROPERTY_0_0 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for SPPHRASEPROPERTY_0_0 { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -10282,8 +10032,6 @@ impl ::windows_core::TypeKind for SPPHRASERULEHANDLE { type TypeKind = ::windows_core::CopyType; } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct SPPHRASE_50 { pub cbSize: u32, pub LangID: u16, @@ -10303,15 +10051,12 @@ pub struct SPPHRASE_50 { pub ulSREnginePrivateDataSize: u32, pub pSREnginePrivateData: *const u8, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for SPPHRASE_50 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPHRASE_50 { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for SPPHRASE_50 { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("SPPHRASE_50") @@ -10335,44 +10080,46 @@ impl ::core::fmt::Debug for SPPHRASE_50 { .finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for SPPHRASE_50 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for SPPHRASE_50 { fn eq(&self, other: &Self) -> bool { self.cbSize == other.cbSize && self.LangID == other.LangID && self.wHomophoneGroupId == other.wHomophoneGroupId && self.ullGrammarID == other.ullGrammarID && self.ftStartTime == other.ftStartTime && self.ullAudioStreamPosition == other.ullAudioStreamPosition && self.ulAudioSizeBytes == other.ulAudioSizeBytes && self.ulRetainedSizeBytes == other.ulRetainedSizeBytes && self.ulAudioSizeTime == other.ulAudioSizeTime && self.Rule == other.Rule && self.pProperties == other.pProperties && self.pElements == other.pElements && self.cReplacements == other.cReplacements && self.pReplacements == other.pReplacements && self.SREngineID == other.SREngineID && self.ulSREnginePrivateDataSize == other.ulSREnginePrivateDataSize && self.pSREnginePrivateData == other.pSREnginePrivateData } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for SPPHRASE_50 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for SPPHRASE_50 { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct SPPROPERTYINFO { pub pszName: ::windows_core::PCWSTR, pub ulId: u32, pub pszValue: ::windows_core::PCWSTR, - pub vValue: super::super::System::Variant::VARIANT, + pub vValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SPPROPERTYINFO { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for SPPROPERTYINFO { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("SPPROPERTYINFO").field("pszName", &self.pszName).field("ulId", &self.ulId).field("pszValue", &self.pszValue).field("vValue", &self.vValue).finish() + } +} impl ::windows_core::TypeKind for SPPROPERTYINFO { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for SPPROPERTYINFO { + fn eq(&self, other: &Self) -> bool { + self.pszName == other.pszName && self.ulId == other.ulId && self.pszValue == other.pszValue && self.vValue == other.vValue + } +} +impl ::core::cmp::Eq for SPPROPERTYINFO {} impl ::core::default::Default for SPPROPERTYINFO { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/impl.rs b/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/impl.rs index 152bd9ca28..190d483ac1 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/impl.rs @@ -1,18 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait INSNetSourceCreator_Impl: Sized { fn Initialize(&self) -> ::windows_core::Result<()>; fn CreateNetSource(&self, pszstreamname: &::windows_core::PCWSTR, pmonitor: ::core::option::Option<&::windows_core::IUnknown>, pdata: *const u8, pusercontext: ::core::option::Option<&::windows_core::IUnknown>, pcallback: ::core::option::Option<&::windows_core::IUnknown>, qwcontext: u64) -> ::windows_core::Result<()>; fn GetNetSourceProperties(&self, pszstreamname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetNetSourceSharedNamespace(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn GetNetSourceAdminInterface(&self, pszstreamname: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetNetSourceAdminInterface(&self, pszstreamname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetNumProtocolsSupported(&self) -> ::windows_core::Result; fn GetProtocolName(&self, dwprotocolnum: u32, pwszprotocolname: ::windows_core::PWSTR, pcchprotocolname: *mut u16) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for INSNetSourceCreator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl INSNetSourceCreator_Vtbl { pub const fn new, Impl: INSNetSourceCreator_Impl, const OFFSET: isize>() -> INSNetSourceCreator_Vtbl { unsafe extern "system" fn Initialize, Impl: INSNetSourceCreator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -47,7 +43,7 @@ impl INSNetSourceCreator_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetNetSourceAdminInterface, Impl: INSNetSourceCreator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetNetSourceAdminInterface, Impl: INSNetSourceCreator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetNetSourceAdminInterface(::core::mem::transmute(&pszstreamname)) { diff --git a/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/mod.rs b/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/mod.rs index c808736655..68e763c3d6 100644 --- a/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Media/WindowsMediaFormat/mod.rs @@ -104,9 +104,7 @@ impl INSNetSourceCreator { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetNetSourceSharedNamespace)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetNetSourceAdminInterface(&self, pszstreamname: P0) -> ::windows_core::Result + pub unsafe fn GetNetSourceAdminInterface(&self, pszstreamname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -132,10 +130,7 @@ pub struct INSNetSourceCreator_Vtbl { pub CreateNetSource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pmonitor: *mut ::core::ffi::c_void, pdata: *const u8, pusercontext: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void, qwcontext: u64) -> ::windows_core::HRESULT, pub GetNetSourceProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pppropertiesnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetNetSourceSharedNamespace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsharednamespace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetNetSourceAdminInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetNetSourceAdminInterface: usize, + pub GetNetSourceAdminInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszstreamname: ::windows_core::PCWSTR, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetNumProtocolsSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcprotocols: *mut u32) -> ::windows_core::HRESULT, pub GetProtocolName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwprotocolnum: u32, pwszprotocolname: ::windows_core::PWSTR, pcchprotocolname: *mut u16) -> ::windows_core::HRESULT, pub Shutdown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/NetworkManagement/MobileBroadband/impl.rs b/crates/libs/windows/src/Windows/Win32/NetworkManagement/MobileBroadband/impl.rs index 127eb0699f..44849260ca 100644 --- a/crates/libs/windows/src/Windows/Win32/NetworkManagement/MobileBroadband/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/NetworkManagement/MobileBroadband/impl.rs @@ -1,9 +1,9 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDummyMBNUCMExt_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDummyMBNUCMExt {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDummyMBNUCMExt_Vtbl { pub const fn new, Impl: IDummyMBNUCMExt_Impl, const OFFSET: isize>() -> IDummyMBNUCMExt_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/impl.rs b/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/impl.rs index 1998c0fb52..f5292499f4 100644 --- a/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/impl.rs @@ -1,17 +1,17 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetPropertyInfo(&self, id: i32) -> ::windows_core::Result<::windows_core::IUnknown>; - fn GetProperty(&self, id: i32) -> ::windows_core::Result; - fn PutProperty(&self, id: i32, pvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, id: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutProperty(&self, id: i32, pvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ResetProperty(&self, id: i32) -> ::windows_core::Result<()>; fn Apply(&self) -> ::windows_core::Result<()>; fn Restore(&self) -> ::windows_core::Result<()>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdo_Vtbl { pub const fn new, Impl: ISdo_Impl, const OFFSET: isize>() -> ISdo_Vtbl { unsafe extern "system" fn GetPropertyInfo, Impl: ISdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, pppropertyinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -25,7 +25,7 @@ impl ISdo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: ISdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ISdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&id)) { @@ -36,7 +36,7 @@ impl ISdo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutProperty, Impl: ISdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, pvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutProperty, Impl: ISdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutProperty(::core::mem::transmute_copy(&id), ::core::mem::transmute_copy(&pvalue)).into() @@ -82,8 +82,8 @@ impl ISdo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdoCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Add(&self, bstrname: &::windows_core::BSTR, ppitem: *mut ::core::option::Option) -> ::windows_core::Result<()>; @@ -91,12 +91,12 @@ pub trait ISdoCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl fn RemoveAll(&self) -> ::windows_core::Result<()>; fn Reload(&self) -> ::windows_core::Result<()>; fn IsNameUnique(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; - fn Item(&self, name: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, name: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdoCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdoCollection_Vtbl { pub const fn new, Impl: ISdoCollection_Impl, const OFFSET: isize>() -> ISdoCollection_Vtbl { unsafe extern "system" fn Count, Impl: ISdoCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -141,7 +141,7 @@ impl ISdoCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: ISdoCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *const super::super::System::Variant::VARIANT, pitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: ISdoCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute_copy(&name)) { @@ -179,26 +179,26 @@ impl ISdoCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdoDictionaryOld_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn EnumAttributes(&self, id: *mut super::super::System::Variant::VARIANT, pvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetAttributeInfo(&self, id: ATTRIBUTEID, pinfoids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn EnumAttributeValues(&self, id: ATTRIBUTEID, pvalueids: *mut super::super::System::Variant::VARIANT, pvaluesdesc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn EnumAttributes(&self, id: *mut ::windows_core::VARIANT, pvalues: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetAttributeInfo(&self, id: ATTRIBUTEID, pinfoids: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn EnumAttributeValues(&self, id: ATTRIBUTEID, pvalueids: *mut ::windows_core::VARIANT, pvaluesdesc: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn CreateAttribute(&self, id: ATTRIBUTEID) -> ::windows_core::Result; fn GetAttributeID(&self, bstrattributename: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdoDictionaryOld {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdoDictionaryOld_Vtbl { pub const fn new, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>() -> ISdoDictionaryOld_Vtbl { - unsafe extern "system" fn EnumAttributes, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut super::super::System::Variant::VARIANT, pvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnumAttributes, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnumAttributes(::core::mem::transmute_copy(&id), ::core::mem::transmute_copy(&pvalues)).into() } - unsafe extern "system" fn GetAttributeInfo, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pinfoids: *const super::super::System::Variant::VARIANT, pinfovalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttributeInfo, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pinfoids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pinfovalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttributeInfo(::core::mem::transmute_copy(&id), ::core::mem::transmute_copy(&pinfoids)) { @@ -209,7 +209,7 @@ impl ISdoDictionaryOld_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnumAttributeValues, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pvalueids: *mut super::super::System::Variant::VARIANT, pvaluesdesc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnumAttributeValues, Impl: ISdoDictionaryOld_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pvalueids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaluesdesc: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnumAttributeValues(::core::mem::transmute_copy(&id), ::core::mem::transmute_copy(&pvalueids), ::core::mem::transmute_copy(&pvaluesdesc)).into() @@ -249,8 +249,8 @@ impl ISdoDictionaryOld_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdoMachine_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Attach(&self, bstrcomputername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetDictionarySDO(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -262,9 +262,9 @@ pub trait ISdoMachine_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetAttachedComputer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetSDOSchema(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdoMachine {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdoMachine_Vtbl { pub const fn new, Impl: ISdoMachine_Impl, const OFFSET: isize>() -> ISdoMachine_Vtbl { unsafe extern "system" fn Attach, Impl: ISdoMachine_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcomputername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -377,8 +377,8 @@ impl ISdoMachine_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdoMachine2_Impl: Sized + ISdoMachine_Impl { fn GetTemplatesSDO(&self, bstrservicename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; fn EnableTemplates(&self) -> ::windows_core::Result<()>; @@ -386,9 +386,9 @@ pub trait ISdoMachine2_Impl: Sized + ISdoMachine_Impl { fn ImportRemoteTemplates(&self, plocaltemplatesroot: ::core::option::Option<&::windows_core::IUnknown>, bstrremotemachinename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Reload(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdoMachine2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdoMachine2_Vtbl { pub const fn new, Impl: ISdoMachine2_Impl, const OFFSET: isize>() -> ISdoMachine2_Vtbl { unsafe extern "system" fn GetTemplatesSDO, Impl: ISdoMachine2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pptemplatessdo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -435,17 +435,17 @@ impl ISdoMachine2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISdoServiceControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartService(&self) -> ::windows_core::Result<()>; fn StopService(&self) -> ::windows_core::Result<()>; fn GetServiceStatus(&self) -> ::windows_core::Result; fn ResetService(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISdoServiceControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISdoServiceControl_Vtbl { pub const fn new, Impl: ISdoServiceControl_Impl, const OFFSET: isize>() -> ISdoServiceControl_Vtbl { unsafe extern "system" fn StartService, Impl: ISdoServiceControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -486,16 +486,16 @@ impl ISdoServiceControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITemplateSdo_Impl: Sized + ISdo_Impl { fn AddToCollection(&self, bstrname: &::windows_core::BSTR, pcollection: ::core::option::Option<&super::super::System::Com::IDispatch>, ppitem: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn AddToSdo(&self, bstrname: &::windows_core::BSTR, psdotarget: ::core::option::Option<&super::super::System::Com::IDispatch>, ppitem: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn AddToSdoAsProperty(&self, psdotarget: ::core::option::Option<&super::super::System::Com::IDispatch>, id: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITemplateSdo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITemplateSdo_Vtbl { pub const fn new, Impl: ITemplateSdo_Impl, const OFFSET: isize>() -> ITemplateSdo_Vtbl { unsafe extern "system" fn AddToCollection, Impl: ITemplateSdo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcollection: *mut ::core::ffi::c_void, ppitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/mod.rs b/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/mod.rs index b8dc4f9c9e..641c4fd017 100644 --- a/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/NetworkManagement/NetworkPolicyServer/mod.rs @@ -13,16 +13,12 @@ impl ISdo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPropertyInfo)(::windows_core::Interface::as_raw(self), id, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, id: i32) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, id: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), id, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutProperty(&self, id: i32, pvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), id, pvalue).ok() + pub unsafe fn PutProperty(&self, id: i32, pvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), id, ::core::mem::transmute(pvalue)).ok() } pub unsafe fn ResetProperty(&self, id: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ResetProperty)(::windows_core::Interface::as_raw(self), id).ok() @@ -44,14 +40,8 @@ impl ISdo { pub struct ISdo_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub GetPropertyInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, pppropertyinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, pvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ResetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32) -> ::windows_core::HRESULT, pub Apply: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Restore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -101,11 +91,11 @@ impl ISdoCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsNameUnique)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, name: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, name: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), name, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(name), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -129,9 +119,9 @@ pub struct ISdoCollection_Vtbl { pub RemoveAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Reload: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub IsNameUnique: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *const super::super::System::Variant::VARIANT, pitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumvariant: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -146,21 +136,15 @@ pub struct ISdoCollection_Vtbl { ::windows_core::imp::interface_hierarchy!(ISdoDictionaryOld, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISdoDictionaryOld { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnumAttributes(&self, id: *mut super::super::System::Variant::VARIANT, pvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EnumAttributes)(::windows_core::Interface::as_raw(self), id, pvalues).ok() - } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeInfo(&self, id: ATTRIBUTEID, pinfoids: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn EnumAttributes(&self, id: *mut ::windows_core::VARIANT, pvalues: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).EnumAttributes)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(id), ::core::mem::transmute(pvalues)).ok() + } + pub unsafe fn GetAttributeInfo(&self, id: ATTRIBUTEID, pinfoids: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetAttributeInfo)(::windows_core::Interface::as_raw(self), id, pinfoids, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetAttributeInfo)(::windows_core::Interface::as_raw(self), id, ::core::mem::transmute(pinfoids), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnumAttributeValues(&self, id: ATTRIBUTEID, pvalueids: *mut super::super::System::Variant::VARIANT, pvaluesdesc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).EnumAttributeValues)(::windows_core::Interface::as_raw(self), id, pvalueids, pvaluesdesc).ok() + pub unsafe fn EnumAttributeValues(&self, id: ATTRIBUTEID, pvalueids: *mut ::windows_core::VARIANT, pvaluesdesc: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).EnumAttributeValues)(::windows_core::Interface::as_raw(self), id, ::core::mem::transmute(pvalueids), ::core::mem::transmute(pvaluesdesc)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -181,18 +165,9 @@ impl ISdoDictionaryOld { #[doc(hidden)] pub struct ISdoDictionaryOld_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnumAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut super::super::System::Variant::VARIANT, pvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnumAttributes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttributeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pinfoids: *const super::super::System::Variant::VARIANT, pinfovalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttributeInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnumAttributeValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pvalueids: *mut super::super::System::Variant::VARIANT, pvaluesdesc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnumAttributeValues: usize, + pub EnumAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetAttributeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pinfoids: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pinfovalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub EnumAttributeValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, pvalueids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaluesdesc: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ATTRIBUTEID, ppattributeobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -414,16 +389,12 @@ impl ITemplateSdo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPropertyInfo)(::windows_core::Interface::as_raw(self), id, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, id: i32) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, id: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), id, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutProperty(&self, id: i32, pvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.PutProperty)(::windows_core::Interface::as_raw(self), id, pvalue).ok() + pub unsafe fn PutProperty(&self, id: i32, pvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.PutProperty)(::windows_core::Interface::as_raw(self), id, ::core::mem::transmute(pvalue)).ok() } pub unsafe fn ResetProperty(&self, id: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ResetProperty)(::windows_core::Interface::as_raw(self), id).ok() diff --git a/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/impl.rs b/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/impl.rs index 8c0344852a..7a6ab345c5 100644 --- a/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDynamicPortMapping_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ExternalIPAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RemoteHost(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -16,9 +16,9 @@ pub trait IDynamicPortMapping_Impl: Sized + super::super::System::Com::IDispatch fn EditDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn EditInternalPort(&self, linternalport: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDynamicPortMapping {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDynamicPortMapping_Vtbl { pub const fn new, Impl: IDynamicPortMapping_Impl, const OFFSET: isize>() -> IDynamicPortMapping_Vtbl { unsafe extern "system" fn ExternalIPAddress, Impl: IDynamicPortMapping_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -173,8 +173,8 @@ impl IDynamicPortMapping_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDynamicPortMappingCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, bstrremotehost: &::windows_core::BSTR, lexternalport: i32, bstrprotocol: &::windows_core::BSTR) -> ::windows_core::Result; @@ -182,9 +182,9 @@ pub trait IDynamicPortMappingCollection_Impl: Sized + super::super::System::Com: fn Remove(&self, bstrremotehost: &::windows_core::BSTR, lexternalport: i32, bstrprotocol: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Add(&self, bstrremotehost: &::windows_core::BSTR, lexternalport: i32, bstrprotocol: &::windows_core::BSTR, linternalport: i32, bstrinternalclient: &::windows_core::BSTR, benabled: super::super::Foundation::VARIANT_BOOL, bstrdescription: &::windows_core::BSTR, lleaseduration: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDynamicPortMappingCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDynamicPortMappingCollection_Vtbl { pub const fn new, Impl: IDynamicPortMappingCollection_Impl, const OFFSET: isize>() -> IDynamicPortMappingCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IDynamicPortMappingCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -296,20 +296,16 @@ impl IEnumNetConnection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumNetSharingEveryConnection_Impl: Sized { - fn Next(&self, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, celt: u32, rgvar: *mut ::windows_core::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumNetSharingEveryConnection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumNetSharingEveryConnection_Vtbl { pub const fn new, Impl: IEnumNetSharingEveryConnection_Impl, const OFFSET: isize>() -> IEnumNetSharingEveryConnection_Vtbl { - unsafe extern "system" fn Next, Impl: IEnumNetSharingEveryConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IEnumNetSharingEveryConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgvar), ::core::mem::transmute_copy(&pceltfetched)).into() @@ -347,20 +343,16 @@ impl IEnumNetSharingEveryConnection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumNetSharingPortMapping_Impl: Sized { - fn Next(&self, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, celt: u32, rgvar: *mut ::windows_core::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumNetSharingPortMapping {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumNetSharingPortMapping_Vtbl { pub const fn new, Impl: IEnumNetSharingPortMapping_Impl, const OFFSET: isize>() -> IEnumNetSharingPortMapping_Vtbl { - unsafe extern "system" fn Next, Impl: IEnumNetSharingPortMapping_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IEnumNetSharingPortMapping_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgvar), ::core::mem::transmute_copy(&pceltfetched)).into() @@ -398,20 +390,16 @@ impl IEnumNetSharingPortMapping_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumNetSharingPrivateConnection_Impl: Sized { - fn Next(&self, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, celt: u32, rgvar: *mut ::windows_core::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumNetSharingPrivateConnection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumNetSharingPrivateConnection_Vtbl { pub const fn new, Impl: IEnumNetSharingPrivateConnection_Impl, const OFFSET: isize>() -> IEnumNetSharingPrivateConnection_Vtbl { - unsafe extern "system" fn Next, Impl: IEnumNetSharingPrivateConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IEnumNetSharingPrivateConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgvar), ::core::mem::transmute_copy(&pceltfetched)).into() @@ -449,20 +437,16 @@ impl IEnumNetSharingPrivateConnection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumNetSharingPublicConnection_Impl: Sized { - fn Next(&self, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; + fn Next(&self, celt: u32, rgvar: *mut ::windows_core::VARIANT, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumNetSharingPublicConnection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumNetSharingPublicConnection_Vtbl { pub const fn new, Impl: IEnumNetSharingPublicConnection_Impl, const OFFSET: isize>() -> IEnumNetSharingPublicConnection_Vtbl { - unsafe extern "system" fn Next, Impl: IEnumNetSharingPublicConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IEnumNetSharingPublicConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgvar), ::core::mem::transmute_copy(&pceltfetched)).into() @@ -500,15 +484,15 @@ impl IEnumNetSharingPublicConnection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INATEventManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetExternalIPAddressCallback(&self, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn SetNumberOfEntriesCallback(&self, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INATEventManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INATEventManager_Vtbl { pub const fn new, Impl: INATEventManager_Impl, const OFFSET: isize>() -> INATEventManager_Vtbl { unsafe extern "system" fn SetExternalIPAddressCallback, Impl: INATEventManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -702,8 +686,8 @@ impl INetConnectionManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetConnectionProps_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Guid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -712,9 +696,9 @@ pub trait INetConnectionProps_Impl: Sized + super::super::System::Com::IDispatch fn MediaType(&self) -> ::windows_core::Result; fn Characteristics(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetConnectionProps {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetConnectionProps_Vtbl { pub const fn new, Impl: INetConnectionProps_Impl, const OFFSET: isize>() -> INetConnectionProps_Vtbl { unsafe extern "system" fn Guid, Impl: INetConnectionProps_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrguid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -797,8 +781,8 @@ impl INetConnectionProps_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwAuthorizedApplication_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -813,9 +797,9 @@ pub trait INetFwAuthorizedApplication_Impl: Sized + super::super::System::Com::I fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwAuthorizedApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwAuthorizedApplication_Vtbl { pub const fn new, Impl: INetFwAuthorizedApplication_Impl, const OFFSET: isize>() -> INetFwAuthorizedApplication_Vtbl { unsafe extern "system" fn Name, Impl: INetFwAuthorizedApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -934,8 +918,8 @@ impl INetFwAuthorizedApplication_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwAuthorizedApplications_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Add(&self, app: ::core::option::Option<&INetFwAuthorizedApplication>) -> ::windows_core::Result<()>; @@ -943,9 +927,9 @@ pub trait INetFwAuthorizedApplications_Impl: Sized + super::super::System::Com:: fn Item(&self, imagefilename: &::windows_core::BSTR) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwAuthorizedApplications {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwAuthorizedApplications_Vtbl { pub const fn new, Impl: INetFwAuthorizedApplications_Impl, const OFFSET: isize>() -> INetFwAuthorizedApplications_Vtbl { unsafe extern "system" fn Count, Impl: INetFwAuthorizedApplications_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -1004,8 +988,8 @@ impl INetFwAuthorizedApplications_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwIcmpSettings_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AllowOutboundDestinationUnreachable(&self) -> ::windows_core::Result; fn SetAllowOutboundDestinationUnreachable(&self, allow: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -1028,9 +1012,9 @@ pub trait INetFwIcmpSettings_Impl: Sized + super::super::System::Com::IDispatch_ fn AllowOutboundPacketTooBig(&self) -> ::windows_core::Result; fn SetAllowOutboundPacketTooBig(&self, allow: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwIcmpSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwIcmpSettings_Vtbl { pub const fn new, Impl: INetFwIcmpSettings_Impl, const OFFSET: isize>() -> INetFwIcmpSettings_Vtbl { unsafe extern "system" fn AllowOutboundDestinationUnreachable, Impl: INetFwIcmpSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, allow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1221,18 +1205,18 @@ impl INetFwIcmpSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwMgr_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LocalPolicy(&self) -> ::windows_core::Result; fn CurrentProfileType(&self) -> ::windows_core::Result; fn RestoreDefaults(&self) -> ::windows_core::Result<()>; - fn IsPortAllowed(&self, imagefilename: &::windows_core::BSTR, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: &::windows_core::BSTR, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn IsIcmpTypeAllowed(&self, ipversion: NET_FW_IP_VERSION, localaddress: &::windows_core::BSTR, r#type: u8, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn IsPortAllowed(&self, imagefilename: &::windows_core::BSTR, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: &::windows_core::BSTR, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut ::windows_core::VARIANT, restricted: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn IsIcmpTypeAllowed(&self, ipversion: NET_FW_IP_VERSION, localaddress: &::windows_core::BSTR, r#type: u8, allowed: *mut ::windows_core::VARIANT, restricted: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwMgr {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwMgr_Vtbl { pub const fn new, Impl: INetFwMgr_Impl, const OFFSET: isize>() -> INetFwMgr_Vtbl { unsafe extern "system" fn LocalPolicy, Impl: INetFwMgr_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, localpolicy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1262,12 +1246,12 @@ impl INetFwMgr_Vtbl { let this = (*this).get_impl(); this.RestoreDefaults().into() } - unsafe extern "system" fn IsPortAllowed, Impl: INetFwMgr_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, imagefilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsPortAllowed, Impl: INetFwMgr_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, imagefilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, restricted: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.IsPortAllowed(::core::mem::transmute(&imagefilename), ::core::mem::transmute_copy(&ipversion), ::core::mem::transmute_copy(&portnumber), ::core::mem::transmute(&localaddress), ::core::mem::transmute_copy(&ipprotocol), ::core::mem::transmute_copy(&allowed), ::core::mem::transmute_copy(&restricted)).into() } - unsafe extern "system" fn IsIcmpTypeAllowed, Impl: INetFwMgr_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ipversion: NET_FW_IP_VERSION, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: u8, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsIcmpTypeAllowed, Impl: INetFwMgr_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ipversion: NET_FW_IP_VERSION, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: u8, allowed: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, restricted: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.IsIcmpTypeAllowed(::core::mem::transmute_copy(&ipversion), ::core::mem::transmute(&localaddress), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&allowed), ::core::mem::transmute_copy(&restricted)).into() @@ -1285,8 +1269,8 @@ impl INetFwMgr_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwOpenPort_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1304,9 +1288,9 @@ pub trait INetFwOpenPort_Impl: Sized + super::super::System::Com::IDispatch_Impl fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn BuiltIn(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwOpenPort {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwOpenPort_Vtbl { pub const fn new, Impl: INetFwOpenPort_Impl, const OFFSET: isize>() -> INetFwOpenPort_Vtbl { unsafe extern "system" fn Name, Impl: INetFwOpenPort_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1455,8 +1439,8 @@ impl INetFwOpenPort_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwOpenPorts_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Add(&self, port: ::core::option::Option<&INetFwOpenPort>) -> ::windows_core::Result<()>; @@ -1464,9 +1448,9 @@ pub trait INetFwOpenPorts_Impl: Sized + super::super::System::Com::IDispatch_Imp fn Item(&self, portnumber: i32, ipprotocol: NET_FW_IP_PROTOCOL) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwOpenPorts {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwOpenPorts_Vtbl { pub const fn new, Impl: INetFwOpenPorts_Impl, const OFFSET: isize>() -> INetFwOpenPorts_Vtbl { unsafe extern "system" fn Count, Impl: INetFwOpenPorts_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -1525,15 +1509,15 @@ impl INetFwOpenPorts_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwPolicy_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CurrentProfile(&self) -> ::windows_core::Result; fn GetProfileByType(&self, profiletype: NET_FW_PROFILE_TYPE) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwPolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwPolicy_Vtbl { pub const fn new, Impl: INetFwPolicy_Impl, const OFFSET: isize>() -> INetFwPolicy_Vtbl { unsafe extern "system" fn CurrentProfile, Impl: INetFwPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profile: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1568,14 +1552,14 @@ impl INetFwPolicy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwPolicy2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CurrentProfileTypes(&self) -> ::windows_core::Result; fn get_FirewallEnabled(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result; fn put_FirewallEnabled(&self, profiletype: NET_FW_PROFILE_TYPE2, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn get_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result; - fn put_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2, interfaces: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2, interfaces: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn get_BlockAllInboundTraffic(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result; fn put_BlockAllInboundTraffic(&self, profiletype: NET_FW_PROFILE_TYPE2, block: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn get_NotificationsDisabled(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result; @@ -1594,9 +1578,9 @@ pub trait INetFwPolicy2_Impl: Sized + super::super::System::Com::IDispatch_Impl fn get_IsRuleGroupCurrentlyEnabled(&self, group: &::windows_core::BSTR) -> ::windows_core::Result; fn LocalPolicyModifyState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwPolicy2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwPolicy2_Vtbl { pub const fn new, Impl: INetFwPolicy2_Impl, const OFFSET: isize>() -> INetFwPolicy2_Vtbl { unsafe extern "system" fn CurrentProfileTypes, Impl: INetFwPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profiletypesbitmask: *mut i32) -> ::windows_core::HRESULT { @@ -1626,7 +1610,7 @@ impl INetFwPolicy2_Vtbl { let this = (*this).get_impl(); this.put_FirewallEnabled(::core::mem::transmute_copy(&profiletype), ::core::mem::transmute_copy(&enabled)).into() } - unsafe extern "system" fn get_ExcludedInterfaces, Impl: INetFwPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_ExcludedInterfaces, Impl: INetFwPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_ExcludedInterfaces(::core::mem::transmute_copy(&profiletype)) { @@ -1637,7 +1621,7 @@ impl INetFwPolicy2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_ExcludedInterfaces, Impl: INetFwPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_ExcludedInterfaces, Impl: INetFwPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_ExcludedInterfaces(::core::mem::transmute_copy(&profiletype), ::core::mem::transmute(&interfaces)).into() @@ -1817,21 +1801,21 @@ impl INetFwPolicy2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwProduct_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn RuleCategories(&self) -> ::windows_core::Result; - fn SetRuleCategories(&self, rulecategories: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RuleCategories(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetRuleCategories(&self, rulecategories: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDisplayName(&self, displayname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PathToSignedProductExe(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwProduct {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwProduct_Vtbl { pub const fn new, Impl: INetFwProduct_Impl, const OFFSET: isize>() -> INetFwProduct_Vtbl { - unsafe extern "system" fn RuleCategories, Impl: INetFwProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulecategories: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RuleCategories, Impl: INetFwProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulecategories: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RuleCategories() { @@ -1842,7 +1826,7 @@ impl INetFwProduct_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetRuleCategories, Impl: INetFwProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulecategories: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetRuleCategories, Impl: INetFwProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rulecategories: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetRuleCategories(::core::mem::transmute(&rulecategories)).into() @@ -1887,17 +1871,17 @@ impl INetFwProduct_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwProducts_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Register(&self, product: ::core::option::Option<&INetFwProduct>) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwProducts {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwProducts_Vtbl { pub const fn new, Impl: INetFwProducts_Impl, const OFFSET: isize>() -> INetFwProducts_Vtbl { unsafe extern "system" fn Count, Impl: INetFwProducts_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -1956,8 +1940,8 @@ impl INetFwProducts_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwProfile_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn FirewallEnabled(&self) -> ::windows_core::Result; @@ -1974,9 +1958,9 @@ pub trait INetFwProfile_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Services(&self) -> ::windows_core::Result; fn AuthorizedApplications(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwProfile {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwProfile_Vtbl { pub const fn new, Impl: INetFwProfile_Impl, const OFFSET: isize>() -> INetFwProfile_Vtbl { unsafe extern "system" fn Type, Impl: INetFwProfile_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: *mut NET_FW_PROFILE_TYPE) -> ::windows_core::HRESULT { @@ -2131,8 +2115,8 @@ impl INetFwProfile_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwRemoteAdminSettings_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IpVersion(&self) -> ::windows_core::Result; fn SetIpVersion(&self, ipversion: NET_FW_IP_VERSION) -> ::windows_core::Result<()>; @@ -2143,9 +2127,9 @@ pub trait INetFwRemoteAdminSettings_Impl: Sized + super::super::System::Com::IDi fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwRemoteAdminSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwRemoteAdminSettings_Vtbl { pub const fn new, Impl: INetFwRemoteAdminSettings_Impl, const OFFSET: isize>() -> INetFwRemoteAdminSettings_Vtbl { unsafe extern "system" fn IpVersion, Impl: INetFwRemoteAdminSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ipversion: *mut NET_FW_IP_VERSION) -> ::windows_core::HRESULT { @@ -2228,8 +2212,8 @@ impl INetFwRemoteAdminSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2253,8 +2237,8 @@ pub trait INetFwRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetIcmpTypesAndCodes(&self, icmptypesandcodes: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Direction(&self) -> ::windows_core::Result; fn SetDirection(&self, dir: NET_FW_RULE_DIRECTION) -> ::windows_core::Result<()>; - fn Interfaces(&self) -> ::windows_core::Result; - fn SetInterfaces(&self, interfaces: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Interfaces(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetInterfaces(&self, interfaces: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn InterfaceTypes(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetInterfaceTypes(&self, interfacetypes: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Enabled(&self) -> ::windows_core::Result; @@ -2268,9 +2252,9 @@ pub trait INetFwRule_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Action(&self) -> ::windows_core::Result; fn SetAction(&self, action: NET_FW_ACTION) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwRule_Vtbl { pub const fn new, Impl: INetFwRule_Impl, const OFFSET: isize>() -> INetFwRule_Vtbl { unsafe extern "system" fn Name, Impl: INetFwRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2449,7 +2433,7 @@ impl INetFwRule_Vtbl { let this = (*this).get_impl(); this.SetDirection(::core::mem::transmute_copy(&dir)).into() } - unsafe extern "system" fn Interfaces, Impl: INetFwRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, interfaces: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Interfaces, Impl: INetFwRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, interfaces: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Interfaces() { @@ -2460,7 +2444,7 @@ impl INetFwRule_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetInterfaces, Impl: INetFwRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetInterfaces, Impl: INetFwRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, interfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetInterfaces(::core::mem::transmute(&interfaces)).into() @@ -2605,15 +2589,15 @@ impl INetFwRule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwRule2_Impl: Sized + INetFwRule_Impl { fn EdgeTraversalOptions(&self) -> ::windows_core::Result; fn SetEdgeTraversalOptions(&self, loptions: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwRule2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwRule2_Vtbl { pub const fn new, Impl: INetFwRule2_Impl, const OFFSET: isize>() -> INetFwRule2_Vtbl { unsafe extern "system" fn EdgeTraversalOptions, Impl: INetFwRule2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, loptions: *mut i32) -> ::windows_core::HRESULT { @@ -2642,8 +2626,8 @@ impl INetFwRule2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwRule3_Impl: Sized + INetFwRule2_Impl { fn LocalAppPackageId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetLocalAppPackageId(&self, wszpackageid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2658,9 +2642,9 @@ pub trait INetFwRule3_Impl: Sized + INetFwRule2_Impl { fn SecureFlags(&self) -> ::windows_core::Result; fn SetSecureFlags(&self, loptions: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwRule3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwRule3_Vtbl { pub const fn new, Impl: INetFwRule3_Impl, const OFFSET: isize>() -> INetFwRule3_Vtbl { unsafe extern "system" fn LocalAppPackageId, Impl: INetFwRule3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszpackageid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2779,8 +2763,8 @@ impl INetFwRule3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwRules_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Add(&self, rule: ::core::option::Option<&INetFwRule>) -> ::windows_core::Result<()>; @@ -2788,9 +2772,9 @@ pub trait INetFwRules_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwRules {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwRules_Vtbl { pub const fn new, Impl: INetFwRules_Impl, const OFFSET: isize>() -> INetFwRules_Vtbl { unsafe extern "system" fn Count, Impl: INetFwRules_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -2849,8 +2833,8 @@ impl INetFwRules_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwService_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Type(&self) -> ::windows_core::Result; @@ -2865,9 +2849,9 @@ pub trait INetFwService_Impl: Sized + super::super::System::Com::IDispatch_Impl fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn GloballyOpenPorts(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwService_Vtbl { pub const fn new, Impl: INetFwService_Impl, const OFFSET: isize>() -> INetFwService_Vtbl { unsafe extern "system" fn Name, Impl: INetFwService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2998,16 +2982,16 @@ impl INetFwService_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwServiceRestriction_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RestrictService(&self, servicename: &::windows_core::BSTR, appname: &::windows_core::BSTR, restrictservice: super::super::Foundation::VARIANT_BOOL, servicesidrestricted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ServiceRestricted(&self, servicename: &::windows_core::BSTR, appname: &::windows_core::BSTR) -> ::windows_core::Result; fn Rules(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwServiceRestriction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwServiceRestriction_Vtbl { pub const fn new, Impl: INetFwServiceRestriction_Impl, const OFFSET: isize>() -> INetFwServiceRestriction_Vtbl { unsafe extern "system" fn RestrictService, Impl: INetFwServiceRestriction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, appname: ::std::mem::MaybeUninit<::windows_core::BSTR>, restrictservice: super::super::Foundation::VARIANT_BOOL, servicesidrestricted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3048,16 +3032,16 @@ impl INetFwServiceRestriction_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetFwServices_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, svctype: NET_FW_SERVICE_TYPE) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetFwServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetFwServices_Vtbl { pub const fn new, Impl: INetFwServices_Impl, const OFFSET: isize>() -> INetFwServices_Vtbl { unsafe extern "system" fn Count, Impl: INetFwServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -3104,8 +3088,8 @@ impl INetFwServices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingConfiguration_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SharingEnabled(&self) -> ::windows_core::Result; fn SharingConnectionType(&self) -> ::windows_core::Result; @@ -3118,9 +3102,9 @@ pub trait INetSharingConfiguration_Impl: Sized + super::super::System::Com::IDis fn AddPortMapping(&self, bstrname: &::windows_core::BSTR, ucipprotocol: u8, usexternalport: u16, usinternalport: u16, dwoptions: u32, bstrtargetnameoripaddress: &::windows_core::BSTR, etargettype: ICS_TARGETTYPE) -> ::windows_core::Result; fn RemovePortMapping(&self, pmapping: ::core::option::Option<&INetSharingPortMapping>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingConfiguration {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingConfiguration_Vtbl { pub const fn new, Impl: INetSharingConfiguration_Impl, const OFFSET: isize>() -> INetSharingConfiguration_Vtbl { unsafe extern "system" fn SharingEnabled, Impl: INetSharingConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3221,15 +3205,15 @@ impl INetSharingConfiguration_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingEveryConnectionCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingEveryConnectionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingEveryConnectionCollection_Vtbl { pub const fn new, Impl: INetSharingEveryConnectionCollection_Impl, const OFFSET: isize>() -> INetSharingEveryConnectionCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: INetSharingEveryConnectionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3264,8 +3248,8 @@ impl INetSharingEveryConnectionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SharingInstalled(&self) -> ::windows_core::Result; fn get_EnumPublicConnections(&self, flags: SHARINGCONNECTION_ENUM_FLAGS) -> ::windows_core::Result; @@ -3274,9 +3258,9 @@ pub trait INetSharingManager_Impl: Sized + super::super::System::Com::IDispatch_ fn EnumEveryConnection(&self) -> ::windows_core::Result; fn get_NetConnectionProps(&self, pnetconnection: ::core::option::Option<&INetConnection>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingManager_Vtbl { pub const fn new, Impl: INetSharingManager_Impl, const OFFSET: isize>() -> INetSharingManager_Vtbl { unsafe extern "system" fn SharingInstalled, Impl: INetSharingManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbinstalled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3359,17 +3343,17 @@ impl INetSharingManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingPortMapping_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Disable(&self) -> ::windows_core::Result<()>; fn Enable(&self) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingPortMapping {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingPortMapping_Vtbl { pub const fn new, Impl: INetSharingPortMapping_Impl, const OFFSET: isize>() -> INetSharingPortMapping_Vtbl { unsafe extern "system" fn Disable, Impl: INetSharingPortMapping_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3410,15 +3394,15 @@ impl INetSharingPortMapping_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingPortMappingCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingPortMappingCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingPortMappingCollection_Vtbl { pub const fn new, Impl: INetSharingPortMappingCollection_Impl, const OFFSET: isize>() -> INetSharingPortMappingCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: INetSharingPortMappingCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3453,8 +3437,8 @@ impl INetSharingPortMappingCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingPortMappingProps_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IPProtocol(&self) -> ::windows_core::Result; @@ -3465,9 +3449,9 @@ pub trait INetSharingPortMappingProps_Impl: Sized + super::super::System::Com::I fn TargetIPAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Enabled(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingPortMappingProps {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingPortMappingProps_Vtbl { pub const fn new, Impl: INetSharingPortMappingProps_Impl, const OFFSET: isize>() -> INetSharingPortMappingProps_Vtbl { unsafe extern "system" fn Name, Impl: INetSharingPortMappingProps_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3574,15 +3558,15 @@ impl INetSharingPortMappingProps_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingPrivateConnectionCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingPrivateConnectionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingPrivateConnectionCollection_Vtbl { pub const fn new, Impl: INetSharingPrivateConnectionCollection_Impl, const OFFSET: isize>() -> INetSharingPrivateConnectionCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: INetSharingPrivateConnectionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3617,15 +3601,15 @@ impl INetSharingPrivateConnectionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetSharingPublicConnectionCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetSharingPublicConnectionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetSharingPublicConnectionCollection_Vtbl { pub const fn new, Impl: INetSharingPublicConnectionCollection_Impl, const OFFSET: isize>() -> INetSharingPublicConnectionCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: INetSharingPublicConnectionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3660,8 +3644,8 @@ impl INetSharingPublicConnectionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IStaticPortMapping_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ExternalIPAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ExternalPort(&self) -> ::windows_core::Result; @@ -3675,9 +3659,9 @@ pub trait IStaticPortMapping_Impl: Sized + super::super::System::Com::IDispatch_ fn EditDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn EditInternalPort(&self, linternalport: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IStaticPortMapping {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IStaticPortMapping_Vtbl { pub const fn new, Impl: IStaticPortMapping_Impl, const OFFSET: isize>() -> IStaticPortMapping_Vtbl { unsafe extern "system" fn ExternalIPAddress, Impl: IStaticPortMapping_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3796,8 +3780,8 @@ impl IStaticPortMapping_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IStaticPortMappingCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, lexternalport: i32, bstrprotocol: &::windows_core::BSTR) -> ::windows_core::Result; @@ -3805,9 +3789,9 @@ pub trait IStaticPortMappingCollection_Impl: Sized + super::super::System::Com:: fn Remove(&self, lexternalport: i32, bstrprotocol: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Add(&self, lexternalport: i32, bstrprotocol: &::windows_core::BSTR, linternalport: i32, bstrinternalclient: &::windows_core::BSTR, benabled: super::super::Foundation::VARIANT_BOOL, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IStaticPortMappingCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IStaticPortMappingCollection_Vtbl { pub const fn new, Impl: IStaticPortMappingCollection_Impl, const OFFSET: isize>() -> IStaticPortMappingCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IStaticPortMappingCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3872,16 +3856,16 @@ impl IStaticPortMappingCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUPnPNAT_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StaticPortMappingCollection(&self) -> ::windows_core::Result; fn DynamicPortMappingCollection(&self) -> ::windows_core::Result; fn NATEventManager(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUPnPNAT {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUPnPNAT_Vtbl { pub const fn new, Impl: IUPnPNAT_Impl, const OFFSET: isize>() -> IUPnPNAT_Vtbl { unsafe extern "system" fn StaticPortMappingCollection, Impl: IUPnPNAT_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppspms: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/mod.rs b/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/mod.rs index 01a82036b8..cf409d0f1f 100644 --- a/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/NetworkManagement/WindowsFirewall/mod.rs @@ -288,9 +288,7 @@ pub struct IEnumNetConnection_Vtbl { ::windows_core::imp::com_interface!(IEnumNetSharingEveryConnection, IEnumNetSharingEveryConnection_Vtbl, 0xc08956b8_1cd3_11d1_b1c5_00805fc1270e); ::windows_core::imp::interface_hierarchy!(IEnumNetSharingEveryConnection, ::windows_core::IUnknown); impl IEnumNetSharingEveryConnection { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, rgvar: &mut [super::super::System::Variant::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn Next(&self, rgvar: &mut [::windows_core::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvar.len().try_into().unwrap(), ::core::mem::transmute(rgvar.as_ptr()), pceltfetched).ok() } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> { @@ -308,10 +306,7 @@ impl IEnumNetSharingEveryConnection { #[doc(hidden)] pub struct IEnumNetSharingEveryConnection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -319,9 +314,7 @@ pub struct IEnumNetSharingEveryConnection_Vtbl { ::windows_core::imp::com_interface!(IEnumNetSharingPortMapping, IEnumNetSharingPortMapping_Vtbl, 0xc08956b0_1cd3_11d1_b1c5_00805fc1270e); ::windows_core::imp::interface_hierarchy!(IEnumNetSharingPortMapping, ::windows_core::IUnknown); impl IEnumNetSharingPortMapping { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, rgvar: &mut [super::super::System::Variant::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn Next(&self, rgvar: &mut [::windows_core::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvar.len().try_into().unwrap(), ::core::mem::transmute(rgvar.as_ptr()), pceltfetched).ok() } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> { @@ -339,10 +332,7 @@ impl IEnumNetSharingPortMapping { #[doc(hidden)] pub struct IEnumNetSharingPortMapping_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -350,9 +340,7 @@ pub struct IEnumNetSharingPortMapping_Vtbl { ::windows_core::imp::com_interface!(IEnumNetSharingPrivateConnection, IEnumNetSharingPrivateConnection_Vtbl, 0xc08956b5_1cd3_11d1_b1c5_00805fc1270e); ::windows_core::imp::interface_hierarchy!(IEnumNetSharingPrivateConnection, ::windows_core::IUnknown); impl IEnumNetSharingPrivateConnection { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, rgvar: &mut [super::super::System::Variant::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn Next(&self, rgvar: &mut [::windows_core::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvar.len().try_into().unwrap(), ::core::mem::transmute(rgvar.as_ptr()), pceltfetched).ok() } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> { @@ -370,10 +358,7 @@ impl IEnumNetSharingPrivateConnection { #[doc(hidden)] pub struct IEnumNetSharingPrivateConnection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -381,9 +366,7 @@ pub struct IEnumNetSharingPrivateConnection_Vtbl { ::windows_core::imp::com_interface!(IEnumNetSharingPublicConnection, IEnumNetSharingPublicConnection_Vtbl, 0xc08956b4_1cd3_11d1_b1c5_00805fc1270e); ::windows_core::imp::interface_hierarchy!(IEnumNetSharingPublicConnection, ::windows_core::IUnknown); impl IEnumNetSharingPublicConnection { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, rgvar: &mut [super::super::System::Variant::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { + pub unsafe fn Next(&self, rgvar: &mut [::windows_core::VARIANT], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvar.len().try_into().unwrap(), ::core::mem::transmute(rgvar.as_ptr()), pceltfetched).ok() } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::Result<()> { @@ -401,10 +384,7 @@ impl IEnumNetSharingPublicConnection { #[doc(hidden)] pub struct IEnumNetSharingPublicConnection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::super::System::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -914,22 +894,18 @@ impl INetFwMgr { pub unsafe fn RestoreDefaults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RestoreDefaults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsPortAllowed(&self, imagefilename: P0, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: P1, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn IsPortAllowed(&self, imagefilename: P0, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: P1, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut ::windows_core::VARIANT, restricted: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).IsPortAllowed)(::windows_core::Interface::as_raw(self), imagefilename.into_param().abi(), ipversion, portnumber, localaddress.into_param().abi(), ipprotocol, allowed, restricted).ok() + (::windows_core::Interface::vtable(self).IsPortAllowed)(::windows_core::Interface::as_raw(self), imagefilename.into_param().abi(), ipversion, portnumber, localaddress.into_param().abi(), ipprotocol, ::core::mem::transmute(allowed), ::core::mem::transmute(restricted)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsIcmpTypeAllowed(&self, ipversion: NET_FW_IP_VERSION, localaddress: P0, r#type: u8, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn IsIcmpTypeAllowed(&self, ipversion: NET_FW_IP_VERSION, localaddress: P0, r#type: u8, allowed: *mut ::windows_core::VARIANT, restricted: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).IsIcmpTypeAllowed)(::windows_core::Interface::as_raw(self), ipversion, localaddress.into_param().abi(), r#type, allowed, restricted).ok() + (::windows_core::Interface::vtable(self).IsIcmpTypeAllowed)(::windows_core::Interface::as_raw(self), ipversion, localaddress.into_param().abi(), r#type, ::core::mem::transmute(allowed), ::core::mem::transmute(restricted)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -943,14 +919,8 @@ pub struct INetFwMgr_Vtbl { LocalPolicy: usize, pub CurrentProfileType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: *mut NET_FW_PROFILE_TYPE) -> ::windows_core::HRESULT, pub RestoreDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsPortAllowed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, imagefilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsPortAllowed: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsIcmpTypeAllowed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ipversion: NET_FW_IP_VERSION, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: u8, allowed: *mut super::super::System::Variant::VARIANT, restricted: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsIcmpTypeAllowed: usize, + pub IsPortAllowed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, imagefilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipversion: NET_FW_IP_VERSION, portnumber: i32, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, ipprotocol: NET_FW_IP_PROTOCOL, allowed: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, restricted: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub IsIcmpTypeAllowed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ipversion: NET_FW_IP_VERSION, localaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: u8, allowed: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, restricted: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1164,16 +1134,15 @@ impl INetFwPolicy2 { { (::windows_core::Interface::vtable(self).put_FirewallEnabled)(::windows_core::Interface::as_raw(self), profiletype, enabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result { + pub unsafe fn get_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_ExcludedInterfaces)(::windows_core::Interface::as_raw(self), profiletype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).put_ExcludedInterfaces)(::windows_core::Interface::as_raw(self), profiletype, ::core::mem::transmute(interfaces)).ok() + pub unsafe fn put_ExcludedInterfaces(&self, profiletype: NET_FW_PROFILE_TYPE2, interfaces: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).put_ExcludedInterfaces)(::windows_core::Interface::as_raw(self), profiletype, interfaces.into_param().abi()).ok() } pub unsafe fn get_BlockAllInboundTraffic(&self, profiletype: NET_FW_PROFILE_TYPE2) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1268,14 +1237,8 @@ pub struct INetFwPolicy2_Vtbl { pub CurrentProfileTypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletypesbitmask: *mut i32) -> ::windows_core::HRESULT, pub get_FirewallEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, enabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub put_FirewallEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_ExcludedInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_ExcludedInterfaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_ExcludedInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_ExcludedInterfaces: usize, + pub get_ExcludedInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_ExcludedInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, interfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub get_BlockAllInboundTraffic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, block: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub put_BlockAllInboundTraffic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, block: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub get_NotificationsDisabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, profiletype: NET_FW_PROFILE_TYPE2, disabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -1311,16 +1274,15 @@ pub struct INetFwPolicy2_Vtbl { ::windows_core::imp::interface_hierarchy!(INetFwProduct, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl INetFwProduct { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RuleCategories(&self) -> ::windows_core::Result { + pub unsafe fn RuleCategories(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).RuleCategories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetRuleCategories(&self, rulecategories: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetRuleCategories)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rulecategories)).ok() + pub unsafe fn SetRuleCategories(&self, rulecategories: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetRuleCategories)(::windows_core::Interface::as_raw(self), rulecategories.into_param().abi()).ok() } pub unsafe fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -1342,14 +1304,8 @@ impl INetFwProduct { #[doc(hidden)] pub struct INetFwProduct_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RuleCategories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulecategories: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RuleCategories: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetRuleCategories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulecategories: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetRuleCategories: usize, + pub RuleCategories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulecategories: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetRuleCategories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rulecategories: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DisplayName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, displayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDisplayName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, displayname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PathToSignedProductExe: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1701,16 +1657,15 @@ impl INetFwRule { pub unsafe fn SetDirection(&self, dir: NET_FW_RULE_DIRECTION) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetDirection)(::windows_core::Interface::as_raw(self), dir).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Interfaces(&self) -> ::windows_core::Result { + pub unsafe fn Interfaces(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Interfaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetInterfaces(&self, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetInterfaces)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(interfaces)).ok() + pub unsafe fn SetInterfaces(&self, interfaces: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetInterfaces)(::windows_core::Interface::as_raw(self), interfaces.into_param().abi()).ok() } pub unsafe fn InterfaceTypes(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -1794,14 +1749,8 @@ pub struct INetFwRule_Vtbl { pub SetIcmpTypesAndCodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, icmptypesandcodes: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Direction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dir: *mut NET_FW_RULE_DIRECTION) -> ::windows_core::HRESULT, pub SetDirection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dir: NET_FW_RULE_DIRECTION) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Interfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfaces: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Interfaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetInterfaces: usize, + pub Interfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfaces: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub InterfaceTypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfacetypes: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetInterfaceTypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, interfacetypes: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Enabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -1930,16 +1879,15 @@ impl INetFwRule2 { pub unsafe fn SetDirection(&self, dir: NET_FW_RULE_DIRECTION) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetDirection)(::windows_core::Interface::as_raw(self), dir).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Interfaces(&self) -> ::windows_core::Result { + pub unsafe fn Interfaces(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Interfaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetInterfaces(&self, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetInterfaces)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(interfaces)).ok() + pub unsafe fn SetInterfaces(&self, interfaces: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetInterfaces)(::windows_core::Interface::as_raw(self), interfaces.into_param().abi()).ok() } pub unsafe fn InterfaceTypes(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2126,16 +2074,15 @@ impl INetFwRule3 { pub unsafe fn SetDirection(&self, dir: NET_FW_RULE_DIRECTION) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.SetDirection)(::windows_core::Interface::as_raw(self), dir).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Interfaces(&self) -> ::windows_core::Result { + pub unsafe fn Interfaces(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Interfaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetInterfaces(&self, interfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetInterfaces)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(interfaces)).ok() + pub unsafe fn SetInterfaces(&self, interfaces: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetInterfaces)(::windows_core::Interface::as_raw(self), interfaces.into_param().abi()).ok() } pub unsafe fn InterfaceTypes(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/impl.rs b/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/impl.rs index e59570e805..e272ce83fb 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Class(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -9,15 +9,15 @@ pub trait IADs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Schema(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetInfo(&self) -> ::windows_core::Result<()>; fn SetInfo(&self) -> ::windows_core::Result<()>; - fn Get(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; - fn Put(&self, bstrname: &::windows_core::BSTR, vprop: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetEx(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; - fn PutEx(&self, lncontrolcode: i32, bstrname: &::windows_core::BSTR, vprop: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetInfoEx(&self, vproperties: &super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()>; + fn Get(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Put(&self, bstrname: &::windows_core::BSTR, vprop: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetEx(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutEx(&self, lncontrolcode: i32, bstrname: &::windows_core::BSTR, vprop: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetInfoEx(&self, vproperties: &::windows_core::VARIANT, lnreserved: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADs_Vtbl { pub const fn new, Impl: IADs_Impl, const OFFSET: isize>() -> IADs_Vtbl { unsafe extern "system" fn Name, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -96,7 +96,7 @@ impl IADs_Vtbl { let this = (*this).get_impl(); this.SetInfo().into() } - unsafe extern "system" fn Get, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Get, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Get(::core::mem::transmute(&bstrname)) { @@ -107,12 +107,12 @@ impl IADs_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Put, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Put, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Put(::core::mem::transmute(&bstrname), ::core::mem::transmute(&vprop)).into() } - unsafe extern "system" fn GetEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetEx(::core::mem::transmute(&bstrname)) { @@ -123,12 +123,12 @@ impl IADs_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lncontrolcode: i32, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lncontrolcode: i32, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutEx(::core::mem::transmute_copy(&lncontrolcode), ::core::mem::transmute(&bstrname), ::core::mem::transmute(&vprop)).into() } - unsafe extern "system" fn GetInfoEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetInfoEx, Impl: IADs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lnreserved: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetInfoEx(::core::mem::transmute(&vproperties), ::core::mem::transmute_copy(&lnreserved)).into() @@ -154,8 +154,8 @@ impl IADs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsADSystemInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UserName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ComputerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -169,11 +169,11 @@ pub trait IADsADSystemInfo_Impl: Sized + super::super::System::Com::IDispatch_Im fn GetAnyDCName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetDCSiteName(&self, szserver: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn RefreshSchemaCache(&self) -> ::windows_core::Result<()>; - fn GetTrees(&self) -> ::windows_core::Result; + fn GetTrees(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsADSystemInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsADSystemInfo_Vtbl { pub const fn new, Impl: IADsADSystemInfo_Impl, const OFFSET: isize>() -> IADsADSystemInfo_Vtbl { unsafe extern "system" fn UserName, Impl: IADsADSystemInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -302,7 +302,7 @@ impl IADsADSystemInfo_Vtbl { let this = (*this).get_impl(); this.RefreshSchemaCache().into() } - unsafe extern "system" fn GetTrees, Impl: IADsADSystemInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtrees: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetTrees, Impl: IADsADSystemInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtrees: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetTrees() { @@ -334,8 +334,8 @@ impl IADsADSystemInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsAccessControlEntry_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AccessMask(&self) -> ::windows_core::Result; fn SetAccessMask(&self, lnaccessmask: i32) -> ::windows_core::Result<()>; @@ -352,9 +352,9 @@ pub trait IADsAccessControlEntry_Impl: Sized + super::super::System::Com::IDispa fn Trustee(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTrustee(&self, bstrtrustee: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsAccessControlEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsAccessControlEntry_Vtbl { pub const fn new, Impl: IADsAccessControlEntry_Impl, const OFFSET: isize>() -> IADsAccessControlEntry_Vtbl { unsafe extern "system" fn AccessMask, Impl: IADsAccessControlEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -491,8 +491,8 @@ impl IADsAccessControlEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsAccessControlList_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AclRevision(&self) -> ::windows_core::Result; fn SetAclRevision(&self, lnaclrevision: i32) -> ::windows_core::Result<()>; @@ -503,9 +503,9 @@ pub trait IADsAccessControlList_Impl: Sized + super::super::System::Com::IDispat fn CopyAccessList(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsAccessControlList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsAccessControlList_Vtbl { pub const fn new, Impl: IADsAccessControlList_Impl, const OFFSET: isize>() -> IADsAccessControlList_Vtbl { unsafe extern "system" fn AclRevision, Impl: IADsAccessControlList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -588,8 +588,8 @@ impl IADsAccessControlList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsAcl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ProtectedAttrName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetProtectedAttrName(&self, bstrprotectedattrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -599,9 +599,9 @@ pub trait IADsAcl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetPrivileges(&self, lnprivileges: i32) -> ::windows_core::Result<()>; fn CopyAcl(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsAcl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsAcl_Vtbl { pub const fn new, Impl: IADsAcl_Impl, const OFFSET: isize>() -> IADsAcl_Vtbl { unsafe extern "system" fn ProtectedAttrName, Impl: IADsAcl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -746,17 +746,17 @@ impl IADsAggregator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsBackLink_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn RemoteID(&self) -> ::windows_core::Result; fn SetRemoteID(&self, lnremoteid: i32) -> ::windows_core::Result<()>; fn ObjectName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetObjectName(&self, bstrobjectname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsBackLink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsBackLink_Vtbl { pub const fn new, Impl: IADsBackLink_Impl, const OFFSET: isize>() -> IADsBackLink_Vtbl { unsafe extern "system" fn RemoteID, Impl: IADsBackLink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -803,18 +803,18 @@ impl IADsBackLink_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsCaseIgnoreList_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn CaseIgnoreList(&self) -> ::windows_core::Result; - fn SetCaseIgnoreList(&self, vcaseignorelist: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CaseIgnoreList(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCaseIgnoreList(&self, vcaseignorelist: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsCaseIgnoreList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsCaseIgnoreList_Vtbl { pub const fn new, Impl: IADsCaseIgnoreList_Impl, const OFFSET: isize>() -> IADsCaseIgnoreList_Vtbl { - unsafe extern "system" fn CaseIgnoreList, Impl: IADsCaseIgnoreList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CaseIgnoreList, Impl: IADsCaseIgnoreList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CaseIgnoreList() { @@ -825,7 +825,7 @@ impl IADsCaseIgnoreList_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCaseIgnoreList, Impl: IADsCaseIgnoreList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vcaseignorelist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCaseIgnoreList, Impl: IADsCaseIgnoreList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vcaseignorelist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCaseIgnoreList(::core::mem::transmute(&vcaseignorelist)).into() @@ -840,8 +840,8 @@ impl IADsCaseIgnoreList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsClass_Impl: Sized + IADs_Impl { fn PrimaryInterface(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CLSID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -852,20 +852,20 @@ pub trait IADsClass_Impl: Sized + IADs_Impl { fn SetAbstract(&self, fabstract: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Auxiliary(&self) -> ::windows_core::Result; fn SetAuxiliary(&self, fauxiliary: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn MandatoryProperties(&self) -> ::windows_core::Result; - fn SetMandatoryProperties(&self, vmandatoryproperties: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn OptionalProperties(&self) -> ::windows_core::Result; - fn SetOptionalProperties(&self, voptionalproperties: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn NamingProperties(&self) -> ::windows_core::Result; - fn SetNamingProperties(&self, vnamingproperties: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DerivedFrom(&self) -> ::windows_core::Result; - fn SetDerivedFrom(&self, vderivedfrom: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AuxDerivedFrom(&self) -> ::windows_core::Result; - fn SetAuxDerivedFrom(&self, vauxderivedfrom: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PossibleSuperiors(&self) -> ::windows_core::Result; - fn SetPossibleSuperiors(&self, vpossiblesuperiors: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Containment(&self) -> ::windows_core::Result; - fn SetContainment(&self, vcontainment: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn MandatoryProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetMandatoryProperties(&self, vmandatoryproperties: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn OptionalProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetOptionalProperties(&self, voptionalproperties: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn NamingProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetNamingProperties(&self, vnamingproperties: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DerivedFrom(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDerivedFrom(&self, vderivedfrom: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AuxDerivedFrom(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetAuxDerivedFrom(&self, vauxderivedfrom: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PossibleSuperiors(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPossibleSuperiors(&self, vpossiblesuperiors: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Containment(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetContainment(&self, vcontainment: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Container(&self) -> ::windows_core::Result; fn SetContainer(&self, fcontainer: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn HelpFileName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -874,9 +874,9 @@ pub trait IADsClass_Impl: Sized + IADs_Impl { fn SetHelpFileContext(&self, lnhelpfilecontext: i32) -> ::windows_core::Result<()>; fn Qualifiers(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsClass {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsClass_Vtbl { pub const fn new, Impl: IADsClass_Impl, const OFFSET: isize>() -> IADsClass_Vtbl { unsafe extern "system" fn PrimaryInterface, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -954,7 +954,7 @@ impl IADsClass_Vtbl { let this = (*this).get_impl(); this.SetAuxiliary(::core::mem::transmute_copy(&fauxiliary)).into() } - unsafe extern "system" fn MandatoryProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn MandatoryProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MandatoryProperties() { @@ -965,12 +965,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetMandatoryProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vmandatoryproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetMandatoryProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vmandatoryproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetMandatoryProperties(::core::mem::transmute(&vmandatoryproperties)).into() } - unsafe extern "system" fn OptionalProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OptionalProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OptionalProperties() { @@ -981,12 +981,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOptionalProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voptionalproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOptionalProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voptionalproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOptionalProperties(::core::mem::transmute(&voptionalproperties)).into() } - unsafe extern "system" fn NamingProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NamingProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NamingProperties() { @@ -997,12 +997,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetNamingProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnamingproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetNamingProperties, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnamingproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetNamingProperties(::core::mem::transmute(&vnamingproperties)).into() } - unsafe extern "system" fn DerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DerivedFrom() { @@ -1013,12 +1013,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vderivedfrom: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDerivedFrom(::core::mem::transmute(&vderivedfrom)).into() } - unsafe extern "system" fn AuxDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AuxDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AuxDerivedFrom() { @@ -1029,12 +1029,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetAuxDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vauxderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetAuxDerivedFrom, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vauxderivedfrom: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetAuxDerivedFrom(::core::mem::transmute(&vauxderivedfrom)).into() } - unsafe extern "system" fn PossibleSuperiors, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PossibleSuperiors, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PossibleSuperiors() { @@ -1045,12 +1045,12 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPossibleSuperiors, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpossiblesuperiors: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPossibleSuperiors, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpossiblesuperiors: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPossibleSuperiors(::core::mem::transmute(&vpossiblesuperiors)).into() } - unsafe extern "system" fn Containment, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Containment, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Containment() { @@ -1061,7 +1061,7 @@ impl IADsClass_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetContainment, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vcontainment: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetContainment, Impl: IADsClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vcontainment: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetContainment(::core::mem::transmute(&vcontainment)).into() @@ -1163,17 +1163,17 @@ impl IADsClass_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Add(&self, bstrname: &::windows_core::BSTR, vitem: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Add(&self, bstrname: &::windows_core::BSTR, vitem: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Remove(&self, bstritemtoberemoved: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetObject(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetObject(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsCollection_Vtbl { pub const fn new, Impl: IADsCollection_Impl, const OFFSET: isize>() -> IADsCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IADsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1187,7 +1187,7 @@ impl IADsCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: IADsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vitem: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IADsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute(&bstrname), ::core::mem::transmute(&vitem)).into() @@ -1197,7 +1197,7 @@ impl IADsCollection_Vtbl { let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&bstritemtoberemoved)).into() } - unsafe extern "system" fn GetObject, Impl: IADsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvitem: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetObject, Impl: IADsCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetObject(::core::mem::transmute(&bstrname)) { @@ -1220,8 +1220,8 @@ impl IADsCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsComputer_Impl: Sized + IADs_Impl { fn ComputerID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Site(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1253,12 +1253,12 @@ pub trait IADsComputer_Impl: Sized + IADs_Impl { fn SetMemorySize(&self, bstrmemorysize: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn StorageCapacity(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetStorageCapacity(&self, bstrstoragecapacity: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn NetAddresses(&self) -> ::windows_core::Result; - fn SetNetAddresses(&self, vnetaddresses: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn NetAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetNetAddresses(&self, vnetaddresses: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsComputer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsComputer_Vtbl { pub const fn new, Impl: IADsComputer_Impl, const OFFSET: isize>() -> IADsComputer_Vtbl { unsafe extern "system" fn ComputerID, Impl: IADsComputer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1507,7 +1507,7 @@ impl IADsComputer_Vtbl { let this = (*this).get_impl(); this.SetStorageCapacity(::core::mem::transmute(&bstrstoragecapacity)).into() } - unsafe extern "system" fn NetAddresses, Impl: IADsComputer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NetAddresses, Impl: IADsComputer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NetAddresses() { @@ -1518,7 +1518,7 @@ impl IADsComputer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetNetAddresses, Impl: IADsComputer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetNetAddresses, Impl: IADsComputer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnetaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetNetAddresses(::core::mem::transmute(&vnetaddresses)).into() @@ -1563,15 +1563,15 @@ impl IADsComputer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsComputerOperations_Impl: Sized + IADs_Impl { fn Status(&self) -> ::windows_core::Result; fn Shutdown(&self, breboot: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsComputerOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsComputerOperations_Vtbl { pub const fn new, Impl: IADsComputerOperations_Impl, const OFFSET: isize>() -> IADsComputerOperations_Vtbl { unsafe extern "system" fn Status, Impl: IADsComputerOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1596,24 +1596,24 @@ impl IADsComputerOperations_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsContainer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Filter(&self) -> ::windows_core::Result; - fn SetFilter(&self, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Hints(&self) -> ::windows_core::Result; - fn SetHints(&self, vhints: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Filter(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetFilter(&self, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Hints(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetHints(&self, vhints: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetObject(&self, classname: &::windows_core::BSTR, relativename: &::windows_core::BSTR) -> ::windows_core::Result; fn Create(&self, classname: &::windows_core::BSTR, relativename: &::windows_core::BSTR) -> ::windows_core::Result; fn Delete(&self, bstrclassname: &::windows_core::BSTR, bstrrelativename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CopyHere(&self, sourcename: &::windows_core::BSTR, newname: &::windows_core::BSTR) -> ::windows_core::Result; fn MoveHere(&self, sourcename: &::windows_core::BSTR, newname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsContainer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsContainer_Vtbl { pub const fn new, Impl: IADsContainer_Impl, const OFFSET: isize>() -> IADsContainer_Vtbl { unsafe extern "system" fn Count, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -1638,7 +1638,7 @@ impl IADsContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Filter, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Filter, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Filter() { @@ -1649,12 +1649,12 @@ impl IADsContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetFilter, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetFilter, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetFilter(::core::mem::transmute(&var)).into() } - unsafe extern "system" fn Hints, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Hints, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Hints() { @@ -1665,7 +1665,7 @@ impl IADsContainer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetHints, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vhints: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetHints, Impl: IADsContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vhints: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetHints(::core::mem::transmute(&vhints)).into() @@ -1738,20 +1738,20 @@ impl IADsContainer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsDNWithBinary_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn BinaryValue(&self) -> ::windows_core::Result; - fn SetBinaryValue(&self, vbinaryvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn BinaryValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBinaryValue(&self, vbinaryvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DNString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDNString(&self, bstrdnstring: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsDNWithBinary {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsDNWithBinary_Vtbl { pub const fn new, Impl: IADsDNWithBinary_Impl, const OFFSET: isize>() -> IADsDNWithBinary_Vtbl { - unsafe extern "system" fn BinaryValue, Impl: IADsDNWithBinary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BinaryValue, Impl: IADsDNWithBinary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BinaryValue() { @@ -1762,7 +1762,7 @@ impl IADsDNWithBinary_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBinaryValue, Impl: IADsDNWithBinary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vbinaryvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBinaryValue, Impl: IADsDNWithBinary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vbinaryvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBinaryValue(::core::mem::transmute(&vbinaryvalue)).into() @@ -1795,17 +1795,17 @@ impl IADsDNWithBinary_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsDNWithString_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StringValue(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetStringValue(&self, bstrstringvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DNString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDNString(&self, bstrdnstring: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsDNWithString {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsDNWithString_Vtbl { pub const fn new, Impl: IADsDNWithString_Impl, const OFFSET: isize>() -> IADsDNWithString_Vtbl { unsafe extern "system" fn StringValue, Impl: IADsDNWithString_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1852,14 +1852,14 @@ impl IADsDNWithString_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsDeleteOps_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DeleteObject(&self, lnflags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsDeleteOps {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsDeleteOps_Vtbl { pub const fn new, Impl: IADsDeleteOps_Impl, const OFFSET: isize>() -> IADsDeleteOps_Vtbl { unsafe extern "system" fn DeleteObject, Impl: IADsDeleteOps_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnflags: i32) -> ::windows_core::HRESULT { @@ -1873,8 +1873,8 @@ impl IADsDeleteOps_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsDomain_Impl: Sized + IADs_Impl { fn IsWorkgroup(&self) -> ::windows_core::Result; fn MinPasswordLength(&self) -> ::windows_core::Result; @@ -1894,9 +1894,9 @@ pub trait IADsDomain_Impl: Sized + IADs_Impl { fn LockoutObservationInterval(&self) -> ::windows_core::Result; fn SetLockoutObservationInterval(&self, lnlockoutobservationinterval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsDomain {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsDomain_Vtbl { pub const fn new, Impl: IADsDomain_Impl, const OFFSET: isize>() -> IADsDomain_Vtbl { unsafe extern "system" fn IsWorkgroup, Impl: IADsDomain_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2063,17 +2063,17 @@ impl IADsDomain_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsEmail_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn SetType(&self, lntype: i32) -> ::windows_core::Result<()>; fn Address(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAddress(&self, bstraddress: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsEmail {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsEmail_Vtbl { pub const fn new, Impl: IADsEmail_Impl, const OFFSET: isize>() -> IADsEmail_Vtbl { unsafe extern "system" fn Type, Impl: IADsEmail_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2120,19 +2120,19 @@ impl IADsEmail_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsExtension_Impl: Sized { - fn Operate(&self, dwcode: u32, vardata1: &super::super::System::Variant::VARIANT, vardata2: &super::super::System::Variant::VARIANT, vardata3: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Operate(&self, dwcode: u32, vardata1: &::windows_core::VARIANT, vardata2: &::windows_core::VARIANT, vardata3: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn PrivateGetIDsOfNames(&self, riid: *const ::windows_core::GUID, rgsznames: *const *const u16, cnames: u32, lcid: u32) -> ::windows_core::Result; - fn PrivateInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn PrivateInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsExtension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsExtension_Vtbl { pub const fn new, Impl: IADsExtension_Impl, const OFFSET: isize>() -> IADsExtension_Vtbl { - unsafe extern "system" fn Operate, Impl: IADsExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcode: u32, vardata1: super::super::System::Variant::VARIANT, vardata2: super::super::System::Variant::VARIANT, vardata3: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Operate, Impl: IADsExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwcode: u32, vardata1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vardata2: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vardata3: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Operate(::core::mem::transmute_copy(&dwcode), ::core::mem::transmute(&vardata1), ::core::mem::transmute(&vardata2), ::core::mem::transmute(&vardata3)).into() @@ -2148,7 +2148,7 @@ impl IADsExtension_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PrivateInvoke, Impl: IADsExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn PrivateInvoke, Impl: IADsExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PrivateInvoke(::core::mem::transmute_copy(&dispidmember), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() @@ -2164,17 +2164,17 @@ impl IADsExtension_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsFaxNumber_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TelephoneNumber(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTelephoneNumber(&self, bstrtelephonenumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Parameters(&self) -> ::windows_core::Result; - fn SetParameters(&self, vparameters: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Parameters(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetParameters(&self, vparameters: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsFaxNumber {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsFaxNumber_Vtbl { pub const fn new, Impl: IADsFaxNumber_Impl, const OFFSET: isize>() -> IADsFaxNumber_Vtbl { unsafe extern "system" fn TelephoneNumber, Impl: IADsFaxNumber_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2193,7 +2193,7 @@ impl IADsFaxNumber_Vtbl { let this = (*this).get_impl(); this.SetTelephoneNumber(::core::mem::transmute(&bstrtelephonenumber)).into() } - unsafe extern "system" fn Parameters, Impl: IADsFaxNumber_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Parameters, Impl: IADsFaxNumber_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Parameters() { @@ -2204,7 +2204,7 @@ impl IADsFaxNumber_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetParameters, Impl: IADsFaxNumber_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vparameters: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParameters, Impl: IADsFaxNumber_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vparameters: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParameters(::core::mem::transmute(&vparameters)).into() @@ -2221,17 +2221,17 @@ impl IADsFaxNumber_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsFileService_Impl: Sized + IADsService_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn MaxUserCount(&self) -> ::windows_core::Result; fn SetMaxUserCount(&self, lnmaxusercount: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsFileService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsFileService_Vtbl { pub const fn new, Impl: IADsFileService_Impl, const OFFSET: isize>() -> IADsFileService_Vtbl { unsafe extern "system" fn Description, Impl: IADsFileService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2278,15 +2278,15 @@ impl IADsFileService_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsFileServiceOperations_Impl: Sized + IADsServiceOperations_Impl { fn Sessions(&self) -> ::windows_core::Result; fn Resources(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsFileServiceOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsFileServiceOperations_Vtbl { pub const fn new, Impl: IADsFileServiceOperations_Impl, const OFFSET: isize>() -> IADsFileServiceOperations_Vtbl { unsafe extern "system" fn Sessions, Impl: IADsFileServiceOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsessions: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2321,8 +2321,8 @@ impl IADsFileServiceOperations_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsFileShare_Impl: Sized + IADs_Impl { fn CurrentUserCount(&self) -> ::windows_core::Result; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2334,9 +2334,9 @@ pub trait IADsFileShare_Impl: Sized + IADs_Impl { fn MaxUserCount(&self) -> ::windows_core::Result; fn SetMaxUserCount(&self, lnmaxusercount: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsFileShare {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsFileShare_Vtbl { pub const fn new, Impl: IADsFileShare_Impl, const OFFSET: isize>() -> IADsFileShare_Vtbl { unsafe extern "system" fn CurrentUserCount, Impl: IADsFileShare_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2431,8 +2431,8 @@ impl IADsFileShare_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsGroup_Impl: Sized + IADs_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2441,9 +2441,9 @@ pub trait IADsGroup_Impl: Sized + IADs_Impl { fn Add(&self, bstrnewitem: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Remove(&self, bstritemtoberemoved: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsGroup_Vtbl { pub const fn new, Impl: IADsGroup_Impl, const OFFSET: isize>() -> IADsGroup_Vtbl { unsafe extern "system" fn Description, Impl: IADsGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2508,17 +2508,17 @@ impl IADsGroup_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsHold_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ObjectName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetObjectName(&self, bstrobjectname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Amount(&self) -> ::windows_core::Result; fn SetAmount(&self, lnamount: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsHold {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsHold_Vtbl { pub const fn new, Impl: IADsHold_Impl, const OFFSET: isize>() -> IADsHold_Vtbl { unsafe extern "system" fn ObjectName, Impl: IADsHold_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2565,17 +2565,17 @@ impl IADsHold_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsLargeInteger_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn HighPart(&self) -> ::windows_core::Result; fn SetHighPart(&self, lnhighpart: i32) -> ::windows_core::Result<()>; fn LowPart(&self) -> ::windows_core::Result; fn SetLowPart(&self, lnlowpart: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsLargeInteger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsLargeInteger_Vtbl { pub const fn new, Impl: IADsLargeInteger_Impl, const OFFSET: isize>() -> IADsLargeInteger_Vtbl { unsafe extern "system" fn HighPart, Impl: IADsLargeInteger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2622,8 +2622,8 @@ impl IADsLargeInteger_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsLocality_Impl: Sized + IADs_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2631,12 +2631,12 @@ pub trait IADsLocality_Impl: Sized + IADs_Impl { fn SetLocalityName(&self, bstrlocalityname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PostalAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPostalAddress(&self, bstrpostaladdress: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SeeAlso(&self) -> ::windows_core::Result; - fn SetSeeAlso(&self, vseealso: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSeeAlso(&self, vseealso: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsLocality {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsLocality_Vtbl { pub const fn new, Impl: IADsLocality_Impl, const OFFSET: isize>() -> IADsLocality_Vtbl { unsafe extern "system" fn Description, Impl: IADsLocality_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2687,7 +2687,7 @@ impl IADsLocality_Vtbl { let this = (*this).get_impl(); this.SetPostalAddress(::core::mem::transmute(&bstrpostaladdress)).into() } - unsafe extern "system" fn SeeAlso, Impl: IADsLocality_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SeeAlso, Impl: IADsLocality_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SeeAlso() { @@ -2698,7 +2698,7 @@ impl IADsLocality_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSeeAlso, Impl: IADsLocality_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSeeAlso, Impl: IADsLocality_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSeeAlso(::core::mem::transmute(&vseealso)).into() @@ -2719,17 +2719,17 @@ impl IADsLocality_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsMembers_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Filter(&self) -> ::windows_core::Result; - fn SetFilter(&self, pvfilter: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Filter(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetFilter(&self, pvfilter: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsMembers {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsMembers_Vtbl { pub const fn new, Impl: IADsMembers_Impl, const OFFSET: isize>() -> IADsMembers_Vtbl { unsafe extern "system" fn Count, Impl: IADsMembers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2754,7 +2754,7 @@ impl IADsMembers_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Filter, Impl: IADsMembers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Filter, Impl: IADsMembers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Filter() { @@ -2765,7 +2765,7 @@ impl IADsMembers_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetFilter, Impl: IADsMembers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetFilter, Impl: IADsMembers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfilter: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetFilter(::core::mem::transmute(&pvfilter)).into() @@ -2782,20 +2782,20 @@ impl IADsMembers_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsNameTranslate_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetChaseReferral(&self, lnchasereferral: i32) -> ::windows_core::Result<()>; fn Init(&self, lnsettype: i32, bstradspath: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitEx(&self, lnsettype: i32, bstradspath: &::windows_core::BSTR, bstruserid: &::windows_core::BSTR, bstrdomain: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Set(&self, lnsettype: i32, bstradspath: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Get(&self, lnformattype: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn SetEx(&self, lnformattype: i32, pvar: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetEx(&self, lnformattype: i32) -> ::windows_core::Result; + fn SetEx(&self, lnformattype: i32, pvar: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetEx(&self, lnformattype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsNameTranslate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsNameTranslate_Vtbl { pub const fn new, Impl: IADsNameTranslate_Impl, const OFFSET: isize>() -> IADsNameTranslate_Vtbl { unsafe extern "system" fn SetChaseReferral, Impl: IADsNameTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnchasereferral: i32) -> ::windows_core::HRESULT { @@ -2829,12 +2829,12 @@ impl IADsNameTranslate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetEx, Impl: IADsNameTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetEx, Impl: IADsNameTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetEx(::core::mem::transmute_copy(&lnformattype), ::core::mem::transmute(&pvar)).into() } - unsafe extern "system" fn GetEx, Impl: IADsNameTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetEx, Impl: IADsNameTranslate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetEx(::core::mem::transmute_copy(&lnformattype)) { @@ -2860,15 +2860,15 @@ impl IADsNameTranslate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsNamespaces_Impl: Sized + IADs_Impl { fn DefaultContainer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDefaultContainer(&self, bstrdefaultcontainer: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsNamespaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsNamespaces_Vtbl { pub const fn new, Impl: IADsNamespaces_Impl, const OFFSET: isize>() -> IADsNamespaces_Vtbl { unsafe extern "system" fn DefaultContainer, Impl: IADsNamespaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2897,17 +2897,17 @@ impl IADsNamespaces_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsNetAddress_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AddressType(&self) -> ::windows_core::Result; fn SetAddressType(&self, lnaddresstype: i32) -> ::windows_core::Result<()>; - fn Address(&self) -> ::windows_core::Result; - fn SetAddress(&self, vaddress: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Address(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetAddress(&self, vaddress: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsNetAddress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsNetAddress_Vtbl { pub const fn new, Impl: IADsNetAddress_Impl, const OFFSET: isize>() -> IADsNetAddress_Vtbl { unsafe extern "system" fn AddressType, Impl: IADsNetAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2926,7 +2926,7 @@ impl IADsNetAddress_Vtbl { let this = (*this).get_impl(); this.SetAddressType(::core::mem::transmute_copy(&lnaddresstype)).into() } - unsafe extern "system" fn Address, Impl: IADsNetAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Address, Impl: IADsNetAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Address() { @@ -2937,7 +2937,7 @@ impl IADsNetAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetAddress, Impl: IADsNetAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vaddress: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetAddress, Impl: IADsNetAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vaddress: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetAddress(::core::mem::transmute(&vaddress)).into() @@ -2954,8 +2954,8 @@ impl IADsNetAddress_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsO_Impl: Sized + IADs_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2967,12 +2967,12 @@ pub trait IADsO_Impl: Sized + IADs_Impl { fn SetTelephoneNumber(&self, bstrtelephonenumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FaxNumber(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFaxNumber(&self, bstrfaxnumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SeeAlso(&self) -> ::windows_core::Result; - fn SetSeeAlso(&self, vseealso: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSeeAlso(&self, vseealso: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsO {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsO_Vtbl { pub const fn new, Impl: IADsO_Impl, const OFFSET: isize>() -> IADsO_Vtbl { unsafe extern "system" fn Description, Impl: IADsO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3055,7 +3055,7 @@ impl IADsO_Vtbl { let this = (*this).get_impl(); this.SetFaxNumber(::core::mem::transmute(&bstrfaxnumber)).into() } - unsafe extern "system" fn SeeAlso, Impl: IADsO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SeeAlso, Impl: IADsO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SeeAlso() { @@ -3066,7 +3066,7 @@ impl IADsO_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSeeAlso, Impl: IADsO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSeeAlso, Impl: IADsO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSeeAlso(::core::mem::transmute(&vseealso)).into() @@ -3091,8 +3091,8 @@ impl IADsO_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsOU_Impl: Sized + IADs_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3104,14 +3104,14 @@ pub trait IADsOU_Impl: Sized + IADs_Impl { fn SetTelephoneNumber(&self, bstrtelephonenumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FaxNumber(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFaxNumber(&self, bstrfaxnumber: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SeeAlso(&self) -> ::windows_core::Result; - fn SetSeeAlso(&self, vseealso: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSeeAlso(&self, vseealso: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BusinessCategory(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetBusinessCategory(&self, bstrbusinesscategory: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsOU {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsOU_Vtbl { pub const fn new, Impl: IADsOU_Impl, const OFFSET: isize>() -> IADsOU_Vtbl { unsafe extern "system" fn Description, Impl: IADsOU_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3194,7 +3194,7 @@ impl IADsOU_Vtbl { let this = (*this).get_impl(); this.SetFaxNumber(::core::mem::transmute(&bstrfaxnumber)).into() } - unsafe extern "system" fn SeeAlso, Impl: IADsOU_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SeeAlso, Impl: IADsOU_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SeeAlso() { @@ -3205,7 +3205,7 @@ impl IADsOU_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSeeAlso, Impl: IADsOU_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSeeAlso, Impl: IADsOU_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSeeAlso(::core::mem::transmute(&vseealso)).into() @@ -3248,18 +3248,18 @@ impl IADsOU_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsObjectOptions_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn GetOption(&self, lnoption: i32) -> ::windows_core::Result; - fn SetOption(&self, lnoption: i32, vvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetOption(&self, lnoption: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetOption(&self, lnoption: i32, vvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsObjectOptions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsObjectOptions_Vtbl { pub const fn new, Impl: IADsObjectOptions_Impl, const OFFSET: isize>() -> IADsObjectOptions_Vtbl { - unsafe extern "system" fn GetOption, Impl: IADsObjectOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnoption: i32, pvvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetOption, Impl: IADsObjectOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnoption: i32, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetOption(::core::mem::transmute_copy(&lnoption)) { @@ -3270,7 +3270,7 @@ impl IADsObjectOptions_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOption, Impl: IADsObjectOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnoption: i32, vvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOption, Impl: IADsObjectOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnoption: i32, vvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOption(::core::mem::transmute_copy(&lnoption), ::core::mem::transmute(&vvalue)).into() @@ -3285,18 +3285,18 @@ impl IADsObjectOptions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsOctetList_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn OctetList(&self) -> ::windows_core::Result; - fn SetOctetList(&self, voctetlist: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OctetList(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetOctetList(&self, voctetlist: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsOctetList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsOctetList_Vtbl { pub const fn new, Impl: IADsOctetList_Impl, const OFFSET: isize>() -> IADsOctetList_Vtbl { - unsafe extern "system" fn OctetList, Impl: IADsOctetList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OctetList, Impl: IADsOctetList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OctetList() { @@ -3307,7 +3307,7 @@ impl IADsOctetList_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOctetList, Impl: IADsOctetList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voctetlist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOctetList, Impl: IADsOctetList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voctetlist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOctetList(::core::mem::transmute(&voctetlist)).into() @@ -3322,14 +3322,14 @@ impl IADsOctetList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsOpenDSObject_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OpenDSObject(&self, lpszdnname: &::windows_core::BSTR, lpszusername: &::windows_core::BSTR, lpszpassword: &::windows_core::BSTR, lnreserved: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsOpenDSObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsOpenDSObject_Vtbl { pub const fn new, Impl: IADsOpenDSObject_Impl, const OFFSET: isize>() -> IADsOpenDSObject_Vtbl { unsafe extern "system" fn OpenDSObject, Impl: IADsOpenDSObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszdnname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpszusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpszpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnreserved: i32, ppoledsobj: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3349,8 +3349,8 @@ impl IADsOpenDSObject_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPath_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn SetType(&self, lntype: i32) -> ::windows_core::Result<()>; @@ -3359,9 +3359,9 @@ pub trait IADsPath_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPath(&self, bstrpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPath {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPath_Vtbl { pub const fn new, Impl: IADsPath_Impl, const OFFSET: isize>() -> IADsPath_Vtbl { unsafe extern "system" fn Type, Impl: IADsPath_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -3426,8 +3426,8 @@ impl IADsPath_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPathname_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Set(&self, bstradspath: &::windows_core::BSTR, lnsettype: i32) -> ::windows_core::Result<()>; fn SetDisplayType(&self, lndisplaytype: i32) -> ::windows_core::Result<()>; @@ -3441,9 +3441,9 @@ pub trait IADsPathname_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EscapedMode(&self) -> ::windows_core::Result; fn SetEscapedMode(&self, lnescapedmode: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPathname {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPathname_Vtbl { pub const fn new, Impl: IADsPathname_Impl, const OFFSET: isize>() -> IADsPathname_Vtbl { unsafe extern "system" fn Set, Impl: IADsPathname_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradspath: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnsettype: i32) -> ::windows_core::HRESULT { @@ -3556,18 +3556,18 @@ impl IADsPathname_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPostalAddress_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn PostalAddress(&self) -> ::windows_core::Result; - fn SetPostalAddress(&self, vpostaladdress: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PostalAddress(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPostalAddress(&self, vpostaladdress: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPostalAddress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPostalAddress_Vtbl { pub const fn new, Impl: IADsPostalAddress_Impl, const OFFSET: isize>() -> IADsPostalAddress_Vtbl { - unsafe extern "system" fn PostalAddress, Impl: IADsPostalAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PostalAddress, Impl: IADsPostalAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PostalAddress() { @@ -3578,7 +3578,7 @@ impl IADsPostalAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPostalAddress, Impl: IADsPostalAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostaladdress: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPostalAddress, Impl: IADsPostalAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostaladdress: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPostalAddress(::core::mem::transmute(&vpostaladdress)).into() @@ -3593,8 +3593,8 @@ impl IADsPostalAddress_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPrintJob_Impl: Sized + IADs_Impl { fn HostPrintQueue(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn User(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3615,9 +3615,9 @@ pub trait IADsPrintJob_Impl: Sized + IADs_Impl { fn NotifyPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetNotifyPath(&self, bstrnotifypath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPrintJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPrintJob_Vtbl { pub const fn new, Impl: IADsPrintJob_Impl, const OFFSET: isize>() -> IADsPrintJob_Vtbl { unsafe extern "system" fn HostPrintQueue, Impl: IADsPrintJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3808,8 +3808,8 @@ impl IADsPrintJob_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPrintJobOperations_Impl: Sized + IADs_Impl { fn Status(&self) -> ::windows_core::Result; fn TimeElapsed(&self) -> ::windows_core::Result; @@ -3819,9 +3819,9 @@ pub trait IADsPrintJobOperations_Impl: Sized + IADs_Impl { fn Pause(&self) -> ::windows_core::Result<()>; fn Resume(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPrintJobOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPrintJobOperations_Vtbl { pub const fn new, Impl: IADsPrintJobOperations_Impl, const OFFSET: isize>() -> IADsPrintJobOperations_Vtbl { unsafe extern "system" fn Status, Impl: IADsPrintJobOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -3898,8 +3898,8 @@ impl IADsPrintJobOperations_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPrintQueue_Impl: Sized + IADs_Impl { fn PrinterPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPrinterPath(&self, bstrprinterpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3923,14 +3923,14 @@ pub trait IADsPrintQueue_Impl: Sized + IADs_Impl { fn SetPriority(&self, lnpriority: i32) -> ::windows_core::Result<()>; fn BannerPage(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetBannerPage(&self, bstrbannerpage: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn PrintDevices(&self) -> ::windows_core::Result; - fn SetPrintDevices(&self, vprintdevices: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn NetAddresses(&self) -> ::windows_core::Result; - fn SetNetAddresses(&self, vnetaddresses: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PrintDevices(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPrintDevices(&self, vprintdevices: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn NetAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetNetAddresses(&self, vnetaddresses: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPrintQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPrintQueue_Vtbl { pub const fn new, Impl: IADsPrintQueue_Impl, const OFFSET: isize>() -> IADsPrintQueue_Vtbl { unsafe extern "system" fn PrinterPath, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4109,7 +4109,7 @@ impl IADsPrintQueue_Vtbl { let this = (*this).get_impl(); this.SetBannerPage(::core::mem::transmute(&bstrbannerpage)).into() } - unsafe extern "system" fn PrintDevices, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PrintDevices, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PrintDevices() { @@ -4120,12 +4120,12 @@ impl IADsPrintQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPrintDevices, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vprintdevices: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPrintDevices, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vprintdevices: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPrintDevices(::core::mem::transmute(&vprintdevices)).into() } - unsafe extern "system" fn NetAddresses, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NetAddresses, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NetAddresses() { @@ -4136,7 +4136,7 @@ impl IADsPrintQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetNetAddresses, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetNetAddresses, Impl: IADsPrintQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vnetaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetNetAddresses(::core::mem::transmute(&vnetaddresses)).into() @@ -4175,8 +4175,8 @@ impl IADsPrintQueue_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPrintQueueOperations_Impl: Sized + IADs_Impl { fn Status(&self) -> ::windows_core::Result; fn PrintJobs(&self) -> ::windows_core::Result; @@ -4184,9 +4184,9 @@ pub trait IADsPrintQueueOperations_Impl: Sized + IADs_Impl { fn Resume(&self) -> ::windows_core::Result<()>; fn Purge(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPrintQueueOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPrintQueueOperations_Vtbl { pub const fn new, Impl: IADsPrintQueueOperations_Impl, const OFFSET: isize>() -> IADsPrintQueueOperations_Vtbl { unsafe extern "system" fn Status, Impl: IADsPrintQueueOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -4239,8 +4239,8 @@ impl IADsPrintQueueOperations_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsProperty_Impl: Sized + IADs_Impl { fn OID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetOID(&self, bstroid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4254,9 +4254,9 @@ pub trait IADsProperty_Impl: Sized + IADs_Impl { fn SetMultiValued(&self, fmultivalued: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Qualifiers(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsProperty_Vtbl { pub const fn new, Impl: IADsProperty_Impl, const OFFSET: isize>() -> IADsProperty_Vtbl { unsafe extern "system" fn OID, Impl: IADsProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4369,8 +4369,8 @@ impl IADsProperty_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPropertyEntry_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Clear(&self) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4379,12 +4379,12 @@ pub trait IADsPropertyEntry_Impl: Sized + super::super::System::Com::IDispatch_I fn SetADsType(&self, lnadstype: i32) -> ::windows_core::Result<()>; fn ControlCode(&self) -> ::windows_core::Result; fn SetControlCode(&self, lncontrolcode: i32) -> ::windows_core::Result<()>; - fn Values(&self) -> ::windows_core::Result; - fn SetValues(&self, vvalues: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Values(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValues(&self, vvalues: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPropertyEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPropertyEntry_Vtbl { pub const fn new, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>() -> IADsPropertyEntry_Vtbl { unsafe extern "system" fn Clear, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4440,7 +4440,7 @@ impl IADsPropertyEntry_Vtbl { let this = (*this).get_impl(); this.SetControlCode(::core::mem::transmute_copy(&lncontrolcode)).into() } - unsafe extern "system" fn Values, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Values, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Values() { @@ -4451,7 +4451,7 @@ impl IADsPropertyEntry_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValues, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vvalues: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValues, Impl: IADsPropertyEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vvalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValues(::core::mem::transmute(&vvalues)).into() @@ -4473,22 +4473,22 @@ impl IADsPropertyEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPropertyList_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn PropertyCount(&self) -> ::windows_core::Result; - fn Next(&self, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT; + fn Next(&self, pvariant: *mut ::windows_core::VARIANT) -> ::windows_core::HRESULT; fn Skip(&self, celements: i32) -> ::windows_core::HRESULT; fn Reset(&self) -> ::windows_core::Result<()>; - fn Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn GetPropertyItem(&self, bstrname: &::windows_core::BSTR, lnadstype: i32) -> ::windows_core::Result; - fn PutPropertyItem(&self, vardata: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ResetPropertyItem(&self, varentry: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetPropertyItem(&self, bstrname: &::windows_core::BSTR, lnadstype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutPropertyItem(&self, vardata: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ResetPropertyItem(&self, varentry: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn PurgePropertyList(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPropertyList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPropertyList_Vtbl { pub const fn new, Impl: IADsPropertyList_Impl, const OFFSET: isize>() -> IADsPropertyList_Vtbl { unsafe extern "system" fn PropertyCount, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4502,7 +4502,7 @@ impl IADsPropertyList_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Next, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&pvariant)) @@ -4517,7 +4517,7 @@ impl IADsPropertyList_Vtbl { let this = (*this).get_impl(); this.Reset().into() } - unsafe extern "system" fn Item, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&varindex)) { @@ -4528,7 +4528,7 @@ impl IADsPropertyList_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnadstype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnadstype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPropertyItem(::core::mem::transmute(&bstrname), ::core::mem::transmute_copy(&lnadstype)) { @@ -4539,12 +4539,12 @@ impl IADsPropertyList_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutPropertyItem(::core::mem::transmute(&vardata)).into() } - unsafe extern "system" fn ResetPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varentry: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ResetPropertyItem, Impl: IADsPropertyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varentry: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ResetPropertyItem(::core::mem::transmute(&varentry)).into() @@ -4571,8 +4571,8 @@ impl IADsPropertyList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPropertyValue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Clear(&self) -> ::windows_core::Result<()>; fn ADsType(&self) -> ::windows_core::Result; @@ -4591,8 +4591,8 @@ pub trait IADsPropertyValue_Impl: Sized + super::super::System::Com::IDispatch_I fn SetBoolean(&self, lnboolean: i32) -> ::windows_core::Result<()>; fn Integer(&self) -> ::windows_core::Result; fn SetInteger(&self, lninteger: i32) -> ::windows_core::Result<()>; - fn OctetString(&self) -> ::windows_core::Result; - fn SetOctetString(&self, voctetstring: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OctetString(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetOctetString(&self, voctetstring: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SecurityDescriptor(&self) -> ::windows_core::Result; fn SetSecurityDescriptor(&self, psecuritydescriptor: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; fn LargeInteger(&self) -> ::windows_core::Result; @@ -4600,9 +4600,9 @@ pub trait IADsPropertyValue_Impl: Sized + super::super::System::Com::IDispatch_I fn UTCTime(&self) -> ::windows_core::Result; fn SetUTCTime(&self, dautctime: f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPropertyValue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPropertyValue_Vtbl { pub const fn new, Impl: IADsPropertyValue_Impl, const OFFSET: isize>() -> IADsPropertyValue_Vtbl { unsafe extern "system" fn Clear, Impl: IADsPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4738,7 +4738,7 @@ impl IADsPropertyValue_Vtbl { let this = (*this).get_impl(); this.SetInteger(::core::mem::transmute_copy(&lninteger)).into() } - unsafe extern "system" fn OctetString, Impl: IADsPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OctetString, Impl: IADsPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OctetString() { @@ -4749,7 +4749,7 @@ impl IADsPropertyValue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOctetString, Impl: IADsPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voctetstring: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOctetString, Impl: IADsPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, voctetstring: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOctetString(::core::mem::transmute(&voctetstring)).into() @@ -4835,23 +4835,23 @@ impl IADsPropertyValue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsPropertyValue2_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn GetObjectProperty(&self, lnadstype: *mut i32, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PutObjectProperty(&self, lnadstype: i32, vprop: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetObjectProperty(&self, lnadstype: *mut i32, pvprop: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PutObjectProperty(&self, lnadstype: i32, vprop: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsPropertyValue2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsPropertyValue2_Vtbl { pub const fn new, Impl: IADsPropertyValue2_Impl, const OFFSET: isize>() -> IADsPropertyValue2_Vtbl { - unsafe extern "system" fn GetObjectProperty, Impl: IADsPropertyValue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnadstype: *mut i32, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetObjectProperty, Impl: IADsPropertyValue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnadstype: *mut i32, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetObjectProperty(::core::mem::transmute_copy(&lnadstype), ::core::mem::transmute_copy(&pvprop)).into() } - unsafe extern "system" fn PutObjectProperty, Impl: IADsPropertyValue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnadstype: i32, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutObjectProperty, Impl: IADsPropertyValue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lnadstype: i32, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutObjectProperty(::core::mem::transmute_copy(&lnadstype), ::core::mem::transmute(&vprop)).into() @@ -4866,8 +4866,8 @@ impl IADsPropertyValue2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsReplicaPointer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ServerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetServerName(&self, bstrservername: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4877,12 +4877,12 @@ pub trait IADsReplicaPointer_Impl: Sized + super::super::System::Com::IDispatch_ fn SetReplicaNumber(&self, lnreplicanumber: i32) -> ::windows_core::Result<()>; fn Count(&self) -> ::windows_core::Result; fn SetCount(&self, lncount: i32) -> ::windows_core::Result<()>; - fn ReplicaAddressHints(&self) -> ::windows_core::Result; - fn SetReplicaAddressHints(&self, vreplicaaddresshints: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ReplicaAddressHints(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetReplicaAddressHints(&self, vreplicaaddresshints: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsReplicaPointer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsReplicaPointer_Vtbl { pub const fn new, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>() -> IADsReplicaPointer_Vtbl { unsafe extern "system" fn ServerName, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4949,7 +4949,7 @@ impl IADsReplicaPointer_Vtbl { let this = (*this).get_impl(); this.SetCount(::core::mem::transmute_copy(&lncount)).into() } - unsafe extern "system" fn ReplicaAddressHints, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReplicaAddressHints, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReplicaAddressHints() { @@ -4960,7 +4960,7 @@ impl IADsReplicaPointer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetReplicaAddressHints, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vreplicaaddresshints: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetReplicaAddressHints, Impl: IADsReplicaPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vreplicaaddresshints: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetReplicaAddressHints(::core::mem::transmute(&vreplicaaddresshints)).into() @@ -4983,17 +4983,17 @@ impl IADsReplicaPointer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsResource_Impl: Sized + IADs_Impl { fn User(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LockCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsResource {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsResource_Vtbl { pub const fn new, Impl: IADsResource_Impl, const OFFSET: isize>() -> IADsResource_Vtbl { unsafe extern "system" fn User, Impl: IADsResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5052,8 +5052,8 @@ impl IADsResource_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsSecurityDescriptor_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Revision(&self) -> ::windows_core::Result; fn SetRevision(&self, lnrevision: i32) -> ::windows_core::Result<()>; @@ -5077,9 +5077,9 @@ pub trait IADsSecurityDescriptor_Impl: Sized + super::super::System::Com::IDispa fn SetSaclDefaulted(&self, fsacldefaulted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn CopySecurityDescriptor(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsSecurityDescriptor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsSecurityDescriptor_Vtbl { pub const fn new, Impl: IADsSecurityDescriptor_Impl, const OFFSET: isize>() -> IADsSecurityDescriptor_Vtbl { unsafe extern "system" fn Revision, Impl: IADsSecurityDescriptor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -5282,21 +5282,21 @@ impl IADsSecurityDescriptor_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsSecurityUtility_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn GetSecurityDescriptor(&self, varpath: &super::super::System::Variant::VARIANT, lpathformat: i32, lformat: i32) -> ::windows_core::Result; - fn SetSecurityDescriptor(&self, varpath: &super::super::System::Variant::VARIANT, lpathformat: i32, vardata: &super::super::System::Variant::VARIANT, ldataformat: i32) -> ::windows_core::Result<()>; - fn ConvertSecurityDescriptor(&self, varsd: &super::super::System::Variant::VARIANT, ldataformat: i32, loutformat: i32) -> ::windows_core::Result; + fn GetSecurityDescriptor(&self, varpath: &::windows_core::VARIANT, lpathformat: i32, lformat: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSecurityDescriptor(&self, varpath: &::windows_core::VARIANT, lpathformat: i32, vardata: &::windows_core::VARIANT, ldataformat: i32) -> ::windows_core::Result<()>; + fn ConvertSecurityDescriptor(&self, varsd: &::windows_core::VARIANT, ldataformat: i32, loutformat: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn SecurityMask(&self) -> ::windows_core::Result; fn SetSecurityMask(&self, lnsecuritymask: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsSecurityUtility {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsSecurityUtility_Vtbl { pub const fn new, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>() -> IADsSecurityUtility_Vtbl { - unsafe extern "system" fn GetSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, lformat: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lpathformat: i32, lformat: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSecurityDescriptor(::core::mem::transmute(&varpath), ::core::mem::transmute_copy(&lpathformat), ::core::mem::transmute_copy(&lformat)) { @@ -5307,12 +5307,12 @@ impl IADsSecurityUtility_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, vardata: super::super::System::Variant::VARIANT, ldataformat: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lpathformat: i32, vardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ldataformat: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSecurityDescriptor(::core::mem::transmute(&varpath), ::core::mem::transmute_copy(&lpathformat), ::core::mem::transmute(&vardata), ::core::mem::transmute_copy(&ldataformat)).into() } - unsafe extern "system" fn ConvertSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsd: super::super::System::Variant::VARIANT, ldataformat: i32, loutformat: i32, presult: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ConvertSecurityDescriptor, Impl: IADsSecurityUtility_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsd: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ldataformat: i32, loutformat: i32, presult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ConvertSecurityDescriptor(::core::mem::transmute(&varsd), ::core::mem::transmute_copy(&ldataformat), ::core::mem::transmute_copy(&loutformat)) { @@ -5352,8 +5352,8 @@ impl IADsSecurityUtility_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsService_Impl: Sized + IADs_Impl { fn HostComputer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHostComputer(&self, bstrhostcomputer: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5377,12 +5377,12 @@ pub trait IADsService_Impl: Sized + IADs_Impl { fn SetServiceAccountName(&self, bstrserviceaccountname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ServiceAccountPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetServiceAccountPath(&self, bstrserviceaccountpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Dependencies(&self) -> ::windows_core::Result; - fn SetDependencies(&self, vdependencies: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Dependencies(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDependencies(&self, vdependencies: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsService_Vtbl { pub const fn new, Impl: IADsService_Impl, const OFFSET: isize>() -> IADsService_Vtbl { unsafe extern "system" fn HostComputer, Impl: IADsService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5561,7 +5561,7 @@ impl IADsService_Vtbl { let this = (*this).get_impl(); this.SetServiceAccountPath(::core::mem::transmute(&bstrserviceaccountpath)).into() } - unsafe extern "system" fn Dependencies, Impl: IADsService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Dependencies, Impl: IADsService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Dependencies() { @@ -5572,7 +5572,7 @@ impl IADsService_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDependencies, Impl: IADsService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdependencies: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDependencies, Impl: IADsService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdependencies: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDependencies(::core::mem::transmute(&vdependencies)).into() @@ -5609,8 +5609,8 @@ impl IADsService_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsServiceOperations_Impl: Sized + IADs_Impl { fn Status(&self) -> ::windows_core::Result; fn Start(&self) -> ::windows_core::Result<()>; @@ -5619,9 +5619,9 @@ pub trait IADsServiceOperations_Impl: Sized + IADs_Impl { fn Continue(&self) -> ::windows_core::Result<()>; fn SetPassword(&self, bstrnewpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsServiceOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsServiceOperations_Vtbl { pub const fn new, Impl: IADsServiceOperations_Impl, const OFFSET: isize>() -> IADsServiceOperations_Vtbl { unsafe extern "system" fn Status, Impl: IADsServiceOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -5674,8 +5674,8 @@ impl IADsServiceOperations_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsSession_Impl: Sized + IADs_Impl { fn User(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5684,9 +5684,9 @@ pub trait IADsSession_Impl: Sized + IADs_Impl { fn ConnectTime(&self) -> ::windows_core::Result; fn IdleTime(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsSession_Vtbl { pub const fn new, Impl: IADsSession_Impl, const OFFSET: isize>() -> IADsSession_Vtbl { unsafe extern "system" fn User, Impl: IADsSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5769,15 +5769,15 @@ impl IADsSession_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsSyntax_Impl: Sized + IADs_Impl { fn OleAutoDataType(&self) -> ::windows_core::Result; fn SetOleAutoDataType(&self, lnoleautodatatype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsSyntax {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsSyntax_Vtbl { pub const fn new, Impl: IADsSyntax_Impl, const OFFSET: isize>() -> IADsSyntax_Vtbl { unsafe extern "system" fn OleAutoDataType, Impl: IADsSyntax_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -5806,17 +5806,17 @@ impl IADsSyntax_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsTimestamp_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn WholeSeconds(&self) -> ::windows_core::Result; fn SetWholeSeconds(&self, lnwholeseconds: i32) -> ::windows_core::Result<()>; fn EventID(&self) -> ::windows_core::Result; fn SetEventID(&self, lneventid: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsTimestamp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsTimestamp_Vtbl { pub const fn new, Impl: IADsTimestamp_Impl, const OFFSET: isize>() -> IADsTimestamp_Vtbl { unsafe extern "system" fn WholeSeconds, Impl: IADsTimestamp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -5863,8 +5863,8 @@ impl IADsTimestamp_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsTypedName_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ObjectName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetObjectName(&self, bstrobjectname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5873,9 +5873,9 @@ pub trait IADsTypedName_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Interval(&self) -> ::windows_core::Result; fn SetInterval(&self, lninterval: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsTypedName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsTypedName_Vtbl { pub const fn new, Impl: IADsTypedName_Impl, const OFFSET: isize>() -> IADsTypedName_Vtbl { unsafe extern "system" fn ObjectName, Impl: IADsTypedName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5940,8 +5940,8 @@ impl IADsTypedName_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsUser_Impl: Sized + IADs_Impl { fn BadLoginAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BadLoginCount(&self) -> ::windows_core::Result; @@ -5973,24 +5973,24 @@ pub trait IADsUser_Impl: Sized + IADs_Impl { fn SetTitle(&self, bstrtitle: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Manager(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetManager(&self, bstrmanager: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn TelephoneHome(&self) -> ::windows_core::Result; - fn SetTelephoneHome(&self, vtelephonehome: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn TelephoneMobile(&self) -> ::windows_core::Result; - fn SetTelephoneMobile(&self, vtelephonemobile: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn TelephoneNumber(&self) -> ::windows_core::Result; - fn SetTelephoneNumber(&self, vtelephonenumber: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn TelephonePager(&self) -> ::windows_core::Result; - fn SetTelephonePager(&self, vtelephonepager: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn FaxNumber(&self) -> ::windows_core::Result; - fn SetFaxNumber(&self, vfaxnumber: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn OfficeLocations(&self) -> ::windows_core::Result; - fn SetOfficeLocations(&self, vofficelocations: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PostalAddresses(&self) -> ::windows_core::Result; - fn SetPostalAddresses(&self, vpostaladdresses: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PostalCodes(&self) -> ::windows_core::Result; - fn SetPostalCodes(&self, vpostalcodes: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SeeAlso(&self) -> ::windows_core::Result; - fn SetSeeAlso(&self, vseealso: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn TelephoneHome(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetTelephoneHome(&self, vtelephonehome: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn TelephoneMobile(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetTelephoneMobile(&self, vtelephonemobile: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn TelephoneNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetTelephoneNumber(&self, vtelephonenumber: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn TelephonePager(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetTelephonePager(&self, vtelephonepager: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn FaxNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetFaxNumber(&self, vfaxnumber: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn OfficeLocations(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetOfficeLocations(&self, vofficelocations: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PostalAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPostalAddresses(&self, vpostaladdresses: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PostalCodes(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPostalCodes(&self, vpostalcodes: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSeeAlso(&self, vseealso: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AccountDisabled(&self) -> ::windows_core::Result; fn SetAccountDisabled(&self, faccountdisabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn AccountExpirationDate(&self) -> ::windows_core::Result; @@ -6001,10 +6001,10 @@ pub trait IADsUser_Impl: Sized + IADs_Impl { fn SetGraceLoginsRemaining(&self, lngraceloginsremaining: i32) -> ::windows_core::Result<()>; fn IsAccountLocked(&self) -> ::windows_core::Result; fn SetIsAccountLocked(&self, fisaccountlocked: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn LoginHours(&self) -> ::windows_core::Result; - fn SetLoginHours(&self, vloginhours: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn LoginWorkstations(&self) -> ::windows_core::Result; - fn SetLoginWorkstations(&self, vloginworkstations: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn LoginHours(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetLoginHours(&self, vloginhours: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn LoginWorkstations(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetLoginWorkstations(&self, vloginworkstations: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MaxLogins(&self) -> ::windows_core::Result; fn SetMaxLogins(&self, lnmaxlogins: i32) -> ::windows_core::Result<()>; fn MaxStorage(&self) -> ::windows_core::Result; @@ -6021,23 +6021,23 @@ pub trait IADsUser_Impl: Sized + IADs_Impl { fn SetEmailAddress(&self, bstremailaddress: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn HomeDirectory(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHomeDirectory(&self, bstrhomedirectory: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Languages(&self) -> ::windows_core::Result; - fn SetLanguages(&self, vlanguages: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Languages(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetLanguages(&self, vlanguages: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Profile(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetProfile(&self, bstrprofile: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn LoginScript(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetLoginScript(&self, bstrloginscript: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Picture(&self) -> ::windows_core::Result; - fn SetPicture(&self, vpicture: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Picture(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPicture(&self, vpicture: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn HomePage(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHomePage(&self, bstrhomepage: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Groups(&self) -> ::windows_core::Result; fn SetPassword(&self, newpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ChangePassword(&self, bstroldpassword: &::windows_core::BSTR, bstrnewpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsUser {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsUser_Vtbl { pub const fn new, Impl: IADsUser_Impl, const OFFSET: isize>() -> IADsUser_Vtbl { unsafe extern "system" fn BadLoginAddress, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6298,7 +6298,7 @@ impl IADsUser_Vtbl { let this = (*this).get_impl(); this.SetManager(::core::mem::transmute(&bstrmanager)).into() } - unsafe extern "system" fn TelephoneHome, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TelephoneHome, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TelephoneHome() { @@ -6309,12 +6309,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetTelephoneHome, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonehome: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTelephoneHome, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonehome: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTelephoneHome(::core::mem::transmute(&vtelephonehome)).into() } - unsafe extern "system" fn TelephoneMobile, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TelephoneMobile, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TelephoneMobile() { @@ -6325,12 +6325,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetTelephoneMobile, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonemobile: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTelephoneMobile, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonemobile: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTelephoneMobile(::core::mem::transmute(&vtelephonemobile)).into() } - unsafe extern "system" fn TelephoneNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TelephoneNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TelephoneNumber() { @@ -6341,12 +6341,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetTelephoneNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonenumber: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTelephoneNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonenumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTelephoneNumber(::core::mem::transmute(&vtelephonenumber)).into() } - unsafe extern "system" fn TelephonePager, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TelephonePager, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TelephonePager() { @@ -6357,12 +6357,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetTelephonePager, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonepager: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTelephonePager, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtelephonepager: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTelephonePager(::core::mem::transmute(&vtelephonepager)).into() } - unsafe extern "system" fn FaxNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn FaxNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FaxNumber() { @@ -6373,12 +6373,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetFaxNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vfaxnumber: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetFaxNumber, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vfaxnumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetFaxNumber(::core::mem::transmute(&vfaxnumber)).into() } - unsafe extern "system" fn OfficeLocations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OfficeLocations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OfficeLocations() { @@ -6389,12 +6389,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOfficeLocations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vofficelocations: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOfficeLocations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vofficelocations: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOfficeLocations(::core::mem::transmute(&vofficelocations)).into() } - unsafe extern "system" fn PostalAddresses, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PostalAddresses, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PostalAddresses() { @@ -6405,12 +6405,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPostalAddresses, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostaladdresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPostalAddresses, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostaladdresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPostalAddresses(::core::mem::transmute(&vpostaladdresses)).into() } - unsafe extern "system" fn PostalCodes, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PostalCodes, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PostalCodes() { @@ -6421,12 +6421,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPostalCodes, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostalcodes: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPostalCodes, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpostalcodes: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPostalCodes(::core::mem::transmute(&vpostalcodes)).into() } - unsafe extern "system" fn SeeAlso, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SeeAlso, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SeeAlso() { @@ -6437,7 +6437,7 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSeeAlso, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSeeAlso, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSeeAlso(::core::mem::transmute(&vseealso)).into() @@ -6522,7 +6522,7 @@ impl IADsUser_Vtbl { let this = (*this).get_impl(); this.SetIsAccountLocked(::core::mem::transmute_copy(&fisaccountlocked)).into() } - unsafe extern "system" fn LoginHours, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LoginHours, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LoginHours() { @@ -6533,12 +6533,12 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetLoginHours, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vloginhours: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetLoginHours, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vloginhours: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetLoginHours(::core::mem::transmute(&vloginhours)).into() } - unsafe extern "system" fn LoginWorkstations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LoginWorkstations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LoginWorkstations() { @@ -6549,7 +6549,7 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetLoginWorkstations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vloginworkstations: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetLoginWorkstations, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vloginworkstations: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetLoginWorkstations(::core::mem::transmute(&vloginworkstations)).into() @@ -6682,7 +6682,7 @@ impl IADsUser_Vtbl { let this = (*this).get_impl(); this.SetHomeDirectory(::core::mem::transmute(&bstrhomedirectory)).into() } - unsafe extern "system" fn Languages, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Languages, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Languages() { @@ -6693,7 +6693,7 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetLanguages, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vlanguages: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetLanguages, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vlanguages: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetLanguages(::core::mem::transmute(&vlanguages)).into() @@ -6730,7 +6730,7 @@ impl IADsUser_Vtbl { let this = (*this).get_impl(); this.SetLoginScript(::core::mem::transmute(&bstrloginscript)).into() } - unsafe extern "system" fn Picture, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Picture, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Picture() { @@ -6741,7 +6741,7 @@ impl IADsUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPicture, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpicture: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPicture, Impl: IADsUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vpicture: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPicture(::core::mem::transmute(&vpicture)).into() @@ -6882,17 +6882,17 @@ impl IADsUser_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsWinNTSystemInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UserName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ComputerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DomainName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn PDC(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsWinNTSystemInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsWinNTSystemInfo_Vtbl { pub const fn new, Impl: IADsWinNTSystemInfo_Impl, const OFFSET: isize>() -> IADsWinNTSystemInfo_Vtbl { unsafe extern "system" fn UserName, Impl: IADsWinNTSystemInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7661,18 +7661,18 @@ impl IPersistQuery_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrivateDispatch_Impl: Sized { fn ADSIInitializeDispatchManager(&self, dwextensionid: i32) -> ::windows_core::Result<()>; fn ADSIGetTypeInfoCount(&self) -> ::windows_core::Result; fn ADSIGetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows_core::Result; fn ADSIGetIDsOfNames(&self, riid: *const ::windows_core::GUID, rgsznames: *const *const u16, cnames: u32, lcid: u32) -> ::windows_core::Result; - fn ADSIInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn ADSIInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrivateDispatch {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrivateDispatch_Vtbl { pub const fn new, Impl: IPrivateDispatch_Impl, const OFFSET: isize>() -> IPrivateDispatch_Vtbl { unsafe extern "system" fn ADSIInitializeDispatchManager, Impl: IPrivateDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwextensionid: i32) -> ::windows_core::HRESULT { @@ -7713,7 +7713,7 @@ impl IPrivateDispatch_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ADSIInvoke, Impl: IPrivateDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn ADSIInvoke, Impl: IPrivateDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ADSIInvoke(::core::mem::transmute_copy(&dispidmember), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/mod.rs b/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/mod.rs index bce53e9671..e7c450d7ea 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/ActiveDirectory/mod.rs @@ -9,19 +9,15 @@ where let mut result__ = ::std::mem::zeroed(); ADsBuildEnumerator(padscontainer.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn ADsBuildVarArrayInt(lpdwobjecttypes: *mut u32, dwobjecttypes: u32, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("activeds.dll" "system" fn ADsBuildVarArrayInt(lpdwobjecttypes : *mut u32, dwobjecttypes : u32, pvar : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - ADsBuildVarArrayInt(lpdwobjecttypes, dwobjecttypes, pvar).ok() +pub unsafe fn ADsBuildVarArrayInt(lpdwobjecttypes: *mut u32, dwobjecttypes: u32, pvar: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("activeds.dll" "system" fn ADsBuildVarArrayInt(lpdwobjecttypes : *mut u32, dwobjecttypes : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + ADsBuildVarArrayInt(lpdwobjecttypes, dwobjecttypes, ::core::mem::transmute(pvar)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn ADsBuildVarArrayStr(lpppathnames: &[::windows_core::PCWSTR], pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("activeds.dll" "system" fn ADsBuildVarArrayStr(lpppathnames : *const ::windows_core::PCWSTR, dwpathnames : u32, pvar : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - ADsBuildVarArrayStr(::core::mem::transmute(lpppathnames.as_ptr()), lpppathnames.len().try_into().unwrap(), pvar).ok() +pub unsafe fn ADsBuildVarArrayStr(lpppathnames: &[::windows_core::PCWSTR], pvar: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("activeds.dll" "system" fn ADsBuildVarArrayStr(lpppathnames : *const ::windows_core::PCWSTR, dwpathnames : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + ADsBuildVarArrayStr(::core::mem::transmute(lpppathnames.as_ptr()), lpppathnames.len().try_into().unwrap(), ::core::mem::transmute(pvar)).ok() } #[inline] pub unsafe fn ADsDecodeBinaryData(szsrcdata: P0, ppbdestdata: *mut *mut u8, pdwdestlen: *mut u32) -> ::windows_core::Result<()> @@ -36,15 +32,15 @@ pub unsafe fn ADsEncodeBinaryData(pbsrcdata: *mut u8, dwsrclen: u32, ppszdestdat ::windows_targets::link!("activeds.dll" "system" fn ADsEncodeBinaryData(pbsrcdata : *mut u8, dwsrclen : u32, ppszdestdata : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); ADsEncodeBinaryData(pbsrcdata, dwsrclen, ppszdestdata).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Ole\"`"] +#[cfg(feature = "Win32_System_Ole")] #[inline] -pub unsafe fn ADsEnumerateNext(penumvariant: P0, celements: u32, pvar: *mut super::super::System::Variant::VARIANT, pcelementsfetched: *mut u32) -> ::windows_core::Result<()> +pub unsafe fn ADsEnumerateNext(penumvariant: P0, celements: u32, pvar: *mut ::windows_core::VARIANT, pcelementsfetched: *mut u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("activeds.dll" "system" fn ADsEnumerateNext(penumvariant : * mut::core::ffi::c_void, celements : u32, pvar : *mut super::super::System::Variant:: VARIANT, pcelementsfetched : *mut u32) -> ::windows_core::HRESULT); - ADsEnumerateNext(penumvariant.into_param().abi(), celements, pvar, pcelementsfetched).ok() + ::windows_targets::link!("activeds.dll" "system" fn ADsEnumerateNext(penumvariant : * mut::core::ffi::c_void, celements : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pcelementsfetched : *mut u32) -> ::windows_core::HRESULT); + ADsEnumerateNext(penumvariant.into_param().abi(), celements, ::core::mem::transmute(pvar), pcelementsfetched).ok() } #[doc = "Required features: `\"Win32_System_Ole\"`"] #[cfg(feature = "Win32_System_Ole")] @@ -155,12 +151,10 @@ pub unsafe fn AdsFreeAdsValues(padsvalues: *mut ADSVALUE, dwnumvalues: u32) { ::windows_targets::link!("activeds.dll" "system" fn AdsFreeAdsValues(padsvalues : *mut ADSVALUE, dwnumvalues : u32)); AdsFreeAdsValues(padsvalues, dwnumvalues) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn AdsTypeToPropVariant(padsvalues: *mut ADSVALUE, dwnumvalues: u32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("activeds.dll" "system" fn AdsTypeToPropVariant(padsvalues : *mut ADSVALUE, dwnumvalues : u32, pvariant : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - AdsTypeToPropVariant(padsvalues, dwnumvalues, pvariant).ok() +pub unsafe fn AdsTypeToPropVariant(padsvalues: *mut ADSVALUE, dwnumvalues: u32, pvariant: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("activeds.dll" "system" fn AdsTypeToPropVariant(padsvalues : *mut ADSVALUE, dwnumvalues : u32, pvariant : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + AdsTypeToPropVariant(padsvalues, dwnumvalues, ::core::mem::transmute(pvariant)).ok() } #[inline] pub unsafe fn AllocADsMem(cb: u32) -> *mut ::core::ffi::c_void { @@ -175,18 +169,18 @@ where ::windows_targets::link!("activeds.dll" "system" fn AllocADsStr(pstr : ::windows_core::PCWSTR) -> ::windows_core::PWSTR); AllocADsStr(pstr.into_param().abi()) } -#[doc = "Required features: `\"Win32_Security\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Security", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Security\"`"] +#[cfg(feature = "Win32_Security")] #[inline] -pub unsafe fn BinarySDToSecurityDescriptor(psecuritydescriptor: P0, pvarsec: *mut super::super::System::Variant::VARIANT, pszservername: P1, username: P2, password: P3, dwflags: u32) -> ::windows_core::Result<()> +pub unsafe fn BinarySDToSecurityDescriptor(psecuritydescriptor: P0, pvarsec: *mut ::windows_core::VARIANT, pszservername: P1, username: P2, password: P3, dwflags: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, P2: ::windows_core::IntoParam<::windows_core::PCWSTR>, P3: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("activeds.dll" "system" fn BinarySDToSecurityDescriptor(psecuritydescriptor : super::super::Security:: PSECURITY_DESCRIPTOR, pvarsec : *mut super::super::System::Variant:: VARIANT, pszservername : ::windows_core::PCWSTR, username : ::windows_core::PCWSTR, password : ::windows_core::PCWSTR, dwflags : u32) -> ::windows_core::HRESULT); - BinarySDToSecurityDescriptor(psecuritydescriptor.into_param().abi(), pvarsec, pszservername.into_param().abi(), username.into_param().abi(), password.into_param().abi(), dwflags).ok() + ::windows_targets::link!("activeds.dll" "system" fn BinarySDToSecurityDescriptor(psecuritydescriptor : super::super::Security:: PSECURITY_DESCRIPTOR, pvarsec : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pszservername : ::windows_core::PCWSTR, username : ::windows_core::PCWSTR, password : ::windows_core::PCWSTR, dwflags : u32) -> ::windows_core::HRESULT); + BinarySDToSecurityDescriptor(psecuritydescriptor.into_param().abi(), ::core::mem::transmute(pvarsec), pszservername.into_param().abi(), username.into_param().abi(), password.into_param().abi(), dwflags).ok() } #[inline] pub unsafe fn DsAddSidHistoryA(hds: P0, flags: u32, srcdomain: P1, srcprincipal: P2, srcdomaincontroller: P3, srcdomaincreds: ::core::option::Option<*const ::core::ffi::c_void>, dstdomain: P4, dstprincipal: P5) -> u32 @@ -1291,12 +1285,10 @@ where ::windows_targets::link!("activeds.dll" "system" fn FreeADsStr(pstr : ::windows_core::PCWSTR) -> super::super::Foundation:: BOOL); FreeADsStr(pstr.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PropVariantToAdsType(pvariant: *mut super::super::System::Variant::VARIANT, dwnumvariant: u32, ppadsvalues: *mut *mut ADSVALUE, pdwnumvalues: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("activeds.dll" "system" fn PropVariantToAdsType(pvariant : *mut super::super::System::Variant:: VARIANT, dwnumvariant : u32, ppadsvalues : *mut *mut ADSVALUE, pdwnumvalues : *mut u32) -> ::windows_core::HRESULT); - PropVariantToAdsType(pvariant, dwnumvariant, ppadsvalues, pdwnumvalues).ok() +pub unsafe fn PropVariantToAdsType(pvariant: *mut ::windows_core::VARIANT, dwnumvariant: u32, ppadsvalues: *mut *mut ADSVALUE, pdwnumvalues: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("activeds.dll" "system" fn PropVariantToAdsType(pvariant : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, dwnumvariant : u32, ppadsvalues : *mut *mut ADSVALUE, pdwnumvalues : *mut u32) -> ::windows_core::HRESULT); + PropVariantToAdsType(::core::mem::transmute(pvariant), dwnumvariant, ppadsvalues, pdwnumvalues).ok() } #[inline] pub unsafe fn ReallocADsMem(poldmem: *mut ::core::ffi::c_void, cbold: u32, cbnew: u32) -> *mut ::core::ffi::c_void { @@ -1311,17 +1303,18 @@ where ::windows_targets::link!("activeds.dll" "system" fn ReallocADsStr(ppstr : *mut ::windows_core::PWSTR, pstr : ::windows_core::PCWSTR) -> super::super::Foundation:: BOOL); ReallocADsStr(ppstr, pstr.into_param().abi()) } -#[doc = "Required features: `\"Win32_Security\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Security", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Security\"`"] +#[cfg(feature = "Win32_Security")] #[inline] -pub unsafe fn SecurityDescriptorToBinarySD(vvarsecdes: super::super::System::Variant::VARIANT, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, pdwsdlength: *mut u32, pszservername: P0, username: P1, password: P2, dwflags: u32) -> ::windows_core::Result<()> +pub unsafe fn SecurityDescriptorToBinarySD(vvarsecdes: P0, ppsecuritydescriptor: *mut super::super::Security::PSECURITY_DESCRIPTOR, pdwsdlength: *mut u32, pszservername: P1, username: P2, password: P3, dwflags: u32) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, P2: ::windows_core::IntoParam<::windows_core::PCWSTR>, + P3: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("activeds.dll" "system" fn SecurityDescriptorToBinarySD(vvarsecdes : super::super::System::Variant:: VARIANT, ppsecuritydescriptor : *mut super::super::Security:: PSECURITY_DESCRIPTOR, pdwsdlength : *mut u32, pszservername : ::windows_core::PCWSTR, username : ::windows_core::PCWSTR, password : ::windows_core::PCWSTR, dwflags : u32) -> ::windows_core::HRESULT); - SecurityDescriptorToBinarySD(::core::mem::transmute(vvarsecdes), ppsecuritydescriptor, pdwsdlength, pszservername.into_param().abi(), username.into_param().abi(), password.into_param().abi(), dwflags).ok() + ::windows_targets::link!("activeds.dll" "system" fn SecurityDescriptorToBinarySD(vvarsecdes : ::std::mem::MaybeUninit <::windows_core::VARIANT >, ppsecuritydescriptor : *mut super::super::Security:: PSECURITY_DESCRIPTOR, pdwsdlength : *mut u32, pszservername : ::windows_core::PCWSTR, username : ::windows_core::PCWSTR, password : ::windows_core::PCWSTR, dwflags : u32) -> ::windows_core::HRESULT); + SecurityDescriptorToBinarySD(vvarsecdes.into_param().abi(), ppsecuritydescriptor, pdwsdlength, pszservername.into_param().abi(), username.into_param().abi(), password.into_param().abi(), dwflags).ok() } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1364,44 +1357,39 @@ impl IADs { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1417,26 +1405,11 @@ pub struct IADs_Vtbl { pub Schema: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Get: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Put: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetEx: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lncontrolcode: i32, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutEx: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetInfoEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetInfoEx: usize, + pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lncontrolcode: i32, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetInfoEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lnreserved: i32) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1499,9 +1472,7 @@ impl IADsADSystemInfo { pub unsafe fn RefreshSchemaCache(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RefreshSchemaCache)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetTrees(&self) -> ::windows_core::Result { + pub unsafe fn GetTrees(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetTrees)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1523,10 +1494,7 @@ pub struct IADsADSystemInfo_Vtbl { pub GetAnyDCName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszdcname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetDCSiteName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, szserver: ::std::mem::MaybeUninit<::windows_core::BSTR>, pszsitename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RefreshSchemaCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetTrees: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtrees: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetTrees: usize, + pub GetTrees: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtrees: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1852,16 +1820,15 @@ pub struct IADsBackLink_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsCaseIgnoreList, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsCaseIgnoreList { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CaseIgnoreList(&self) -> ::windows_core::Result { + pub unsafe fn CaseIgnoreList(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CaseIgnoreList)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCaseIgnoreList(&self, vcaseignorelist: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCaseIgnoreList)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vcaseignorelist)).ok() + pub unsafe fn SetCaseIgnoreList(&self, vcaseignorelist: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetCaseIgnoreList)(::windows_core::Interface::as_raw(self), vcaseignorelist.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1869,14 +1836,8 @@ impl IADsCaseIgnoreList { #[doc(hidden)] pub struct IADsCaseIgnoreList_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CaseIgnoreList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CaseIgnoreList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCaseIgnoreList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcaseignorelist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCaseIgnoreList: usize, + pub CaseIgnoreList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCaseIgnoreList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcaseignorelist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1919,44 +1880,39 @@ impl IADsClass { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn PrimaryInterface(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2002,82 +1958,75 @@ impl IADsClass { { (::windows_core::Interface::vtable(self).SetAuxiliary)(::windows_core::Interface::as_raw(self), fauxiliary.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MandatoryProperties(&self) -> ::windows_core::Result { + pub unsafe fn MandatoryProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MandatoryProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetMandatoryProperties(&self, vmandatoryproperties: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetMandatoryProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vmandatoryproperties)).ok() + pub unsafe fn SetMandatoryProperties(&self, vmandatoryproperties: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetMandatoryProperties)(::windows_core::Interface::as_raw(self), vmandatoryproperties.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OptionalProperties(&self) -> ::windows_core::Result { + pub unsafe fn OptionalProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).OptionalProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOptionalProperties(&self, voptionalproperties: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOptionalProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(voptionalproperties)).ok() + pub unsafe fn SetOptionalProperties(&self, voptionalproperties: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetOptionalProperties)(::windows_core::Interface::as_raw(self), voptionalproperties.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NamingProperties(&self) -> ::windows_core::Result { + pub unsafe fn NamingProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NamingProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetNamingProperties(&self, vnamingproperties: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetNamingProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vnamingproperties)).ok() + pub unsafe fn SetNamingProperties(&self, vnamingproperties: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetNamingProperties)(::windows_core::Interface::as_raw(self), vnamingproperties.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DerivedFrom(&self) -> ::windows_core::Result { + pub unsafe fn DerivedFrom(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DerivedFrom)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDerivedFrom(&self, vderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDerivedFrom)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vderivedfrom)).ok() + pub unsafe fn SetDerivedFrom(&self, vderivedfrom: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDerivedFrom)(::windows_core::Interface::as_raw(self), vderivedfrom.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AuxDerivedFrom(&self) -> ::windows_core::Result { + pub unsafe fn AuxDerivedFrom(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AuxDerivedFrom)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetAuxDerivedFrom(&self, vauxderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetAuxDerivedFrom)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vauxderivedfrom)).ok() + pub unsafe fn SetAuxDerivedFrom(&self, vauxderivedfrom: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetAuxDerivedFrom)(::windows_core::Interface::as_raw(self), vauxderivedfrom.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PossibleSuperiors(&self) -> ::windows_core::Result { + pub unsafe fn PossibleSuperiors(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PossibleSuperiors)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPossibleSuperiors(&self, vpossiblesuperiors: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPossibleSuperiors)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vpossiblesuperiors)).ok() + pub unsafe fn SetPossibleSuperiors(&self, vpossiblesuperiors: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPossibleSuperiors)(::windows_core::Interface::as_raw(self), vpossiblesuperiors.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Containment(&self) -> ::windows_core::Result { + pub unsafe fn Containment(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Containment)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetContainment(&self, vcontainment: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetContainment)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vcontainment)).ok() + pub unsafe fn SetContainment(&self, vcontainment: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetContainment)(::windows_core::Interface::as_raw(self), vcontainment.into_param().abi()).ok() } pub unsafe fn Container(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2127,62 +2076,20 @@ pub struct IADsClass_Vtbl { pub SetAbstract: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fabstract: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Auxiliary: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetAuxiliary: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fauxiliary: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MandatoryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MandatoryProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetMandatoryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vmandatoryproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetMandatoryProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OptionalProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OptionalProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOptionalProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voptionalproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOptionalProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NamingProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NamingProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetNamingProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnamingproperties: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetNamingProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DerivedFrom: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDerivedFrom: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AuxDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AuxDerivedFrom: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetAuxDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vauxderivedfrom: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetAuxDerivedFrom: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PossibleSuperiors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PossibleSuperiors: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPossibleSuperiors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpossiblesuperiors: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPossibleSuperiors: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Containment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Containment: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetContainment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcontainment: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetContainment: usize, + pub MandatoryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetMandatoryProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vmandatoryproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub OptionalProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetOptionalProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voptionalproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub NamingProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetNamingProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnamingproperties: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vderivedfrom: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AuxDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetAuxDerivedFrom: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vauxderivedfrom: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PossibleSuperiors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPossibleSuperiors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpossiblesuperiors: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Containment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetContainment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcontainment: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Container: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetContainer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fcontainer: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub HelpFileName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -2209,13 +2116,12 @@ impl IADsCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, bstrname: P0, vitem: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Add(&self, bstrname: P0, vitem: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vitem)).ok() + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vitem.into_param().abi()).ok() } pub unsafe fn Remove(&self, bstritemtoberemoved: P0) -> ::windows_core::Result<()> where @@ -2223,9 +2129,7 @@ impl IADsCollection { { (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), bstritemtoberemoved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetObject(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetObject(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -2239,15 +2143,9 @@ impl IADsCollection { pub struct IADsCollection_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vitem: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstritemtoberemoved: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvitem: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetObject: usize, + pub GetObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2290,44 +2188,39 @@ impl IADsComputer { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn ComputerID(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2477,16 +2370,15 @@ impl IADsComputer { { (::windows_core::Interface::vtable(self).SetStorageCapacity)(::windows_core::Interface::as_raw(self), bstrstoragecapacity.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NetAddresses(&self) -> ::windows_core::Result { + pub unsafe fn NetAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NetAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetNetAddresses(&self, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetNetAddresses)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vnetaddresses)).ok() + pub unsafe fn SetNetAddresses(&self, vnetaddresses: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetNetAddresses)(::windows_core::Interface::as_raw(self), vnetaddresses.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2524,14 +2416,8 @@ pub struct IADsComputer_Vtbl { pub SetMemorySize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmemorysize: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub StorageCapacity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetStorageCapacity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrstoragecapacity: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NetAddresses: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetNetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetNetAddresses: usize, + pub NetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetNetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnetaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2574,44 +2460,39 @@ impl IADsComputerOperations { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2656,27 +2537,25 @@ impl IADsContainer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Filter(&self) -> ::windows_core::Result { + pub unsafe fn Filter(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Filter)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetFilter(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var)).ok() + pub unsafe fn SetFilter(&self, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), var.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Hints(&self) -> ::windows_core::Result { + pub unsafe fn Hints(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Hints)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetHints(&self, vhints: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetHints)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vhints)).ok() + pub unsafe fn SetHints(&self, vhints: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetHints)(::windows_core::Interface::as_raw(self), vhints.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2733,22 +2612,10 @@ pub struct IADsContainer_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Filter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Filter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetFilter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Hints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Hints: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vhints: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetHints: usize, + pub Filter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Hints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vhints: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, classname: ::std::mem::MaybeUninit<::windows_core::BSTR>, relativename: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2778,16 +2645,15 @@ pub struct IADsContainer_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsDNWithBinary, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsDNWithBinary { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BinaryValue(&self) -> ::windows_core::Result { + pub unsafe fn BinaryValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BinaryValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBinaryValue(&self, vbinaryvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBinaryValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vbinaryvalue)).ok() + pub unsafe fn SetBinaryValue(&self, vbinaryvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBinaryValue)(::windows_core::Interface::as_raw(self), vbinaryvalue.into_param().abi()).ok() } pub unsafe fn DNString(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2805,14 +2671,8 @@ impl IADsDNWithBinary { #[doc(hidden)] pub struct IADsDNWithBinary_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BinaryValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vbinaryvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBinaryValue: usize, + pub BinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBinaryValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vbinaryvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DNString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDNString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdnstring: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -2921,44 +2781,39 @@ impl IADsDomain { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn IsWorkgroup(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3086,33 +2941,33 @@ pub struct IADsEmail_Vtbl { ::windows_core::imp::com_interface!(IADsExtension, IADsExtension_Vtbl, 0x3d35553c_d2b0_11d1_b17b_0000f87593a0); ::windows_core::imp::interface_hierarchy!(IADsExtension, ::windows_core::IUnknown); impl IADsExtension { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operate(&self, dwcode: u32, vardata1: super::super::System::Variant::VARIANT, vardata2: super::super::System::Variant::VARIANT, vardata3: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Operate)(::windows_core::Interface::as_raw(self), dwcode, ::core::mem::transmute(vardata1), ::core::mem::transmute(vardata2), ::core::mem::transmute(vardata3)).ok() + pub unsafe fn Operate(&self, dwcode: u32, vardata1: P0, vardata2: P1, vardata3: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Operate)(::windows_core::Interface::as_raw(self), dwcode, vardata1.into_param().abi(), vardata2.into_param().abi(), vardata3.into_param().abi()).ok() } pub unsafe fn PrivateGetIDsOfNames(&self, riid: *const ::windows_core::GUID, rgsznames: *const *const u16, cnames: u32, lcid: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PrivateGetIDsOfNames)(::windows_core::Interface::as_raw(self), riid, rgsznames, cnames, lcid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrivateInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PrivateInvoke)(::windows_core::Interface::as_raw(self), dispidmember, riid, lcid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PrivateInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PrivateInvoke)(::windows_core::Interface::as_raw(self), dispidmember, riid, lcid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } } #[repr(C)] #[doc(hidden)] pub struct IADsExtension_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Operate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcode: u32, vardata1: super::super::System::Variant::VARIANT, vardata2: super::super::System::Variant::VARIANT, vardata3: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Operate: usize, + pub Operate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcode: u32, vardata1: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vardata2: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vardata3: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PrivateGetIDsOfNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, rgsznames: *const *const u16, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PrivateInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PrivateInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PrivateInvoke: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3136,16 +2991,15 @@ impl IADsFaxNumber { { (::windows_core::Interface::vtable(self).SetTelephoneNumber)(::windows_core::Interface::as_raw(self), bstrtelephonenumber.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Parameters(&self) -> ::windows_core::Result { + pub unsafe fn Parameters(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Parameters)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameters(&self, vparameters: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetParameters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vparameters)).ok() + pub unsafe fn SetParameters(&self, vparameters: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetParameters)(::windows_core::Interface::as_raw(self), vparameters.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3155,14 +3009,8 @@ pub struct IADsFaxNumber_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub TelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetTelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtelephonenumber: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Parameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Parameters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vparameters: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetParameters: usize, + pub Parameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vparameters: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3205,44 +3053,39 @@ impl IADsFileService { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn HostComputer(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3345,16 +3188,15 @@ impl IADsFileService { { (::windows_core::Interface::vtable(self).base__.SetServiceAccountPath)(::windows_core::Interface::as_raw(self), bstrserviceaccountpath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Dependencies(&self) -> ::windows_core::Result { + pub unsafe fn Dependencies(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Dependencies)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDependencies(&self, vdependencies: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetDependencies)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdependencies)).ok() + pub unsafe fn SetDependencies(&self, vdependencies: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetDependencies)(::windows_core::Interface::as_raw(self), vdependencies.into_param().abi()).ok() } pub unsafe fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3425,44 +3267,39 @@ impl IADsFileServiceOperations { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Status(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3554,44 +3391,39 @@ impl IADsFileShare { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn CurrentUserCount(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3691,44 +3523,39 @@ impl IADsGroup { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3897,44 +3724,39 @@ impl IADsLocality { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3966,16 +3788,15 @@ impl IADsLocality { { (::windows_core::Interface::vtable(self).SetPostalAddress)(::windows_core::Interface::as_raw(self), bstrpostaladdress.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SeeAlso(&self) -> ::windows_core::Result { + pub unsafe fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SeeAlso)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSeeAlso(&self, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vseealso)).ok() + pub unsafe fn SetSeeAlso(&self, vseealso: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), vseealso.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3989,14 +3810,8 @@ pub struct IADsLocality_Vtbl { pub SetLocalityName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrlocalityname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetPostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpostaladdress: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SeeAlso: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSeeAlso: usize, + pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4017,16 +3832,15 @@ impl IADsMembers { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Filter(&self) -> ::windows_core::Result { + pub unsafe fn Filter(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Filter)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetFilter(&self, pvfilter: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvfilter)).ok() + pub unsafe fn SetFilter(&self, pvfilter: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), pvfilter.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4036,14 +3850,8 @@ pub struct IADsMembers_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumerator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Filter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Filter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetFilter: usize, + pub Filter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfilter: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4084,14 +3892,13 @@ impl IADsNameTranslate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), lnformattype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetEx(&self, lnformattype: i32, pvar: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetEx)(::windows_core::Interface::as_raw(self), lnformattype, ::core::mem::transmute(pvar)).ok() + pub unsafe fn SetEx(&self, lnformattype: i32, pvar: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetEx)(::windows_core::Interface::as_raw(self), lnformattype, pvar.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, lnformattype: i32) -> ::windows_core::Result { + pub unsafe fn GetEx(&self, lnformattype: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetEx)(::windows_core::Interface::as_raw(self), lnformattype, &mut result__).from_abi(result__) } @@ -4106,14 +3913,8 @@ pub struct IADsNameTranslate_Vtbl { pub InitEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnsettype: i32, bstradspath: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstruserid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdomain: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Set: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnsettype: i32, bstradspath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnformattype: i32, pbstradspath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetEx: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetEx: usize, + pub SetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnformattype: i32, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4156,44 +3957,39 @@ impl IADsNamespaces { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn DefaultContainer(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4232,16 +4028,15 @@ impl IADsNetAddress { pub unsafe fn SetAddressType(&self, lnaddresstype: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetAddressType)(::windows_core::Interface::as_raw(self), lnaddresstype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Address(&self) -> ::windows_core::Result { + pub unsafe fn Address(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Address)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetAddress(&self, vaddress: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetAddress)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vaddress)).ok() + pub unsafe fn SetAddress(&self, vaddress: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetAddress)(::windows_core::Interface::as_raw(self), vaddress.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4251,14 +4046,8 @@ pub struct IADsNetAddress_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub AddressType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetAddressType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnaddresstype: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Address: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Address: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vaddress: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetAddress: usize, + pub Address: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vaddress: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4301,44 +4090,39 @@ impl IADsO { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4390,16 +4174,15 @@ impl IADsO { { (::windows_core::Interface::vtable(self).SetFaxNumber)(::windows_core::Interface::as_raw(self), bstrfaxnumber.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SeeAlso(&self) -> ::windows_core::Result { + pub unsafe fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SeeAlso)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSeeAlso(&self, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vseealso)).ok() + pub unsafe fn SetSeeAlso(&self, vseealso: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), vseealso.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4417,14 +4200,8 @@ pub struct IADsO_Vtbl { pub SetTelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtelephonenumber: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub FaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetFaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SeeAlso: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSeeAlso: usize, + pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4467,44 +4244,39 @@ impl IADsOU { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4556,16 +4328,15 @@ impl IADsOU { { (::windows_core::Interface::vtable(self).SetFaxNumber)(::windows_core::Interface::as_raw(self), bstrfaxnumber.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SeeAlso(&self) -> ::windows_core::Result { + pub unsafe fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SeeAlso)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSeeAlso(&self, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vseealso)).ok() + pub unsafe fn SetSeeAlso(&self, vseealso: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), vseealso.into_param().abi()).ok() } pub unsafe fn BusinessCategory(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4593,14 +4364,8 @@ pub struct IADsOU_Vtbl { pub SetTelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtelephonenumber: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub FaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetFaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfaxnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SeeAlso: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSeeAlso: usize, + pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BusinessCategory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetBusinessCategory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbusinesscategory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -4615,16 +4380,15 @@ pub struct IADsOU_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsObjectOptions, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsObjectOptions { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetOption(&self, lnoption: i32) -> ::windows_core::Result { + pub unsafe fn GetOption(&self, lnoption: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetOption)(::windows_core::Interface::as_raw(self), lnoption, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, lnoption: i32, vvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), lnoption, ::core::mem::transmute(vvalue)).ok() + pub unsafe fn SetOption(&self, lnoption: i32, vvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), lnoption, vvalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4632,14 +4396,8 @@ impl IADsObjectOptions { #[doc(hidden)] pub struct IADsObjectOptions_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnoption: i32, pvvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetOption: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnoption: i32, vvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOption: usize, + pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnoption: i32, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnoption: i32, vvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4652,16 +4410,15 @@ pub struct IADsObjectOptions_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsOctetList, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsOctetList { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OctetList(&self) -> ::windows_core::Result { + pub unsafe fn OctetList(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).OctetList)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOctetList(&self, voctetlist: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOctetList)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(voctetlist)).ok() + pub unsafe fn SetOctetList(&self, voctetlist: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetOctetList)(::windows_core::Interface::as_raw(self), voctetlist.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4669,14 +4426,8 @@ impl IADsOctetList { #[doc(hidden)] pub struct IADsOctetList_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OctetList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OctetList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOctetList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voctetlist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOctetList: usize, + pub OctetList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetOctetList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voctetlist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4855,16 +4606,15 @@ pub struct IADsPathname_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsPostalAddress, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsPostalAddress { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PostalAddress(&self) -> ::windows_core::Result { + pub unsafe fn PostalAddress(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PostalAddress)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPostalAddress(&self, vpostaladdress: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPostalAddress)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vpostaladdress)).ok() + pub unsafe fn SetPostalAddress(&self, vpostaladdress: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPostalAddress)(::windows_core::Interface::as_raw(self), vpostaladdress.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4872,14 +4622,8 @@ impl IADsPostalAddress { #[doc(hidden)] pub struct IADsPostalAddress_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PostalAddress: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostaladdress: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPostalAddress: usize, + pub PostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPostalAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostaladdress: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4922,44 +4666,39 @@ impl IADsPrintJob { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn HostPrintQueue(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -5102,44 +4841,39 @@ impl IADsPrintJobOperations { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Status(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5221,44 +4955,39 @@ impl IADsPrintQueue { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn PrinterPath(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -5358,27 +5087,25 @@ impl IADsPrintQueue { { (::windows_core::Interface::vtable(self).SetBannerPage)(::windows_core::Interface::as_raw(self), bstrbannerpage.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrintDevices(&self) -> ::windows_core::Result { + pub unsafe fn PrintDevices(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PrintDevices)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPrintDevices(&self, vprintdevices: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPrintDevices)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vprintdevices)).ok() + pub unsafe fn SetPrintDevices(&self, vprintdevices: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPrintDevices)(::windows_core::Interface::as_raw(self), vprintdevices.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NetAddresses(&self) -> ::windows_core::Result { + pub unsafe fn NetAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NetAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetNetAddresses(&self, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetNetAddresses)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vnetaddresses)).ok() + pub unsafe fn SetNetAddresses(&self, vnetaddresses: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetNetAddresses)(::windows_core::Interface::as_raw(self), vnetaddresses.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5408,22 +5135,10 @@ pub struct IADsPrintQueue_Vtbl { pub SetPriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnpriority: i32) -> ::windows_core::HRESULT, pub BannerPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetBannerPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbannerpage: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PrintDevices: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PrintDevices: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPrintDevices: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vprintdevices: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPrintDevices: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NetAddresses: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetNetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnetaddresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetNetAddresses: usize, + pub PrintDevices: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPrintDevices: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vprintdevices: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub NetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetNetAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vnetaddresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5466,44 +5181,39 @@ impl IADsPrintQueueOperations { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Status(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5580,44 +5290,39 @@ impl IADsProperty { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn OID(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -5728,16 +5433,15 @@ impl IADsPropertyEntry { pub unsafe fn SetControlCode(&self, lncontrolcode: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetControlCode)(::windows_core::Interface::as_raw(self), lncontrolcode).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Values(&self) -> ::windows_core::Result { + pub unsafe fn Values(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Values)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValues(&self, vvalues: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValues)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vvalues)).ok() + pub unsafe fn SetValues(&self, vvalues: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValues)(::windows_core::Interface::as_raw(self), vvalues.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5752,14 +5456,8 @@ pub struct IADsPropertyEntry_Vtbl { pub SetADsType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnadstype: i32) -> ::windows_core::HRESULT, pub ControlCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetControlCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lncontrolcode: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Values: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Values: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vvalues: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValues: usize, + pub Values: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vvalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5776,10 +5474,8 @@ impl IADsPropertyList { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PropertyCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), pvariant) + pub unsafe fn Next(&self, pvariant: *mut ::windows_core::VARIANT) -> ::windows_core::HRESULT { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvariant)) } pub unsafe fn Skip(&self, celements: i32) -> ::windows_core::HRESULT { (::windows_core::Interface::vtable(self).Skip)(::windows_core::Interface::as_raw(self), celements) @@ -5787,30 +5483,31 @@ impl IADsPropertyList { pub unsafe fn Reset(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyItem(&self, bstrname: P0, lnadstype: i32) -> ::windows_core::Result + pub unsafe fn GetPropertyItem(&self, bstrname: P0, lnadstype: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPropertyItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), lnadstype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutPropertyItem(&self, vardata: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PutPropertyItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardata)).ok() + pub unsafe fn PutPropertyItem(&self, vardata: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).PutPropertyItem)(::windows_core::Interface::as_raw(self), vardata.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ResetPropertyItem(&self, varentry: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ResetPropertyItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varentry)).ok() + pub unsafe fn ResetPropertyItem(&self, varentry: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ResetPropertyItem)(::windows_core::Interface::as_raw(self), varentry.into_param().abi()).ok() } pub unsafe fn PurgePropertyList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).PurgePropertyList)(::windows_core::Interface::as_raw(self)).ok() @@ -5822,28 +5519,13 @@ impl IADsPropertyList { pub struct IADsPropertyList_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub PropertyCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celements: i32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnadstype: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ResetPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varentry: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ResetPropertyItem: usize, + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lnadstype: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ResetPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varentry: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PurgePropertyList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5931,16 +5613,15 @@ impl IADsPropertyValue { pub unsafe fn SetInteger(&self, lninteger: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetInteger)(::windows_core::Interface::as_raw(self), lninteger).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OctetString(&self) -> ::windows_core::Result { + pub unsafe fn OctetString(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).OctetString)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOctetString(&self, voctetstring: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOctetString)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(voctetstring)).ok() + pub unsafe fn SetOctetString(&self, voctetstring: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetOctetString)(::windows_core::Interface::as_raw(self), voctetstring.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6000,14 +5681,8 @@ pub struct IADsPropertyValue_Vtbl { pub SetBoolean: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnboolean: i32) -> ::windows_core::HRESULT, pub Integer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetInteger: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lninteger: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OctetString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OctetString: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOctetString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voctetstring: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOctetString: usize, + pub OctetString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetOctetString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, voctetstring: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub SecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -6038,15 +5713,14 @@ pub struct IADsPropertyValue_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsPropertyValue2, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsPropertyValue2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetObjectProperty(&self, lnadstype: *mut i32, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetObjectProperty)(::windows_core::Interface::as_raw(self), lnadstype, pvprop).ok() + pub unsafe fn GetObjectProperty(&self, lnadstype: *mut i32, pvprop: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetObjectProperty)(::windows_core::Interface::as_raw(self), lnadstype, ::core::mem::transmute(pvprop)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutObjectProperty(&self, lnadstype: i32, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PutObjectProperty)(::windows_core::Interface::as_raw(self), lnadstype, ::core::mem::transmute(vprop)).ok() + pub unsafe fn PutObjectProperty(&self, lnadstype: i32, vprop: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).PutObjectProperty)(::windows_core::Interface::as_raw(self), lnadstype, vprop.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6054,14 +5728,8 @@ impl IADsPropertyValue2 { #[doc(hidden)] pub struct IADsPropertyValue2_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetObjectProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnadstype: *mut i32, pvprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetObjectProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutObjectProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnadstype: i32, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutObjectProperty: usize, + pub GetObjectProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnadstype: *mut i32, pvprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutObjectProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnadstype: i32, vprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6105,16 +5773,15 @@ impl IADsReplicaPointer { pub unsafe fn SetCount(&self, lncount: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetCount)(::windows_core::Interface::as_raw(self), lncount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReplicaAddressHints(&self) -> ::windows_core::Result { + pub unsafe fn ReplicaAddressHints(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ReplicaAddressHints)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetReplicaAddressHints(&self, vreplicaaddresshints: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetReplicaAddressHints)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vreplicaaddresshints)).ok() + pub unsafe fn SetReplicaAddressHints(&self, vreplicaaddresshints: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetReplicaAddressHints)(::windows_core::Interface::as_raw(self), vreplicaaddresshints.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6130,14 +5797,8 @@ pub struct IADsReplicaPointer_Vtbl { pub SetReplicaNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnreplicanumber: i32) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lncount: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReplicaAddressHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ReplicaAddressHints: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetReplicaAddressHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vreplicaaddresshints: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetReplicaAddressHints: usize, + pub ReplicaAddressHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetReplicaAddressHints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vreplicaaddresshints: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6180,44 +5841,39 @@ impl IADsResource { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn User(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6419,22 +6075,26 @@ pub struct IADsSecurityDescriptor_Vtbl { ::windows_core::imp::interface_hierarchy!(IADsSecurityUtility, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IADsSecurityUtility { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSecurityDescriptor(&self, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, lformat: i32) -> ::windows_core::Result { + pub unsafe fn GetSecurityDescriptor(&self, varpath: P0, lpathformat: i32, lformat: i32) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetSecurityDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varpath), lpathformat, lformat, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetSecurityDescriptor)(::windows_core::Interface::as_raw(self), varpath.into_param().abi(), lpathformat, lformat, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSecurityDescriptor(&self, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, vardata: super::super::System::Variant::VARIANT, ldataformat: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSecurityDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varpath), lpathformat, ::core::mem::transmute(vardata), ldataformat).ok() + pub unsafe fn SetSecurityDescriptor(&self, varpath: P0, lpathformat: i32, vardata: P1, ldataformat: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSecurityDescriptor)(::windows_core::Interface::as_raw(self), varpath.into_param().abi(), lpathformat, vardata.into_param().abi(), ldataformat).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConvertSecurityDescriptor(&self, varsd: super::super::System::Variant::VARIANT, ldataformat: i32, loutformat: i32) -> ::windows_core::Result { + pub unsafe fn ConvertSecurityDescriptor(&self, varsd: P0, ldataformat: i32, loutformat: i32) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ConvertSecurityDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsd), ldataformat, loutformat, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ConvertSecurityDescriptor)(::windows_core::Interface::as_raw(self), varsd.into_param().abi(), ldataformat, loutformat, &mut result__).from_abi(result__) } pub unsafe fn SecurityMask(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6449,18 +6109,9 @@ impl IADsSecurityUtility { #[doc(hidden)] pub struct IADsSecurityUtility_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, lformat: i32, pvariant: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSecurityDescriptor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varpath: super::super::System::Variant::VARIANT, lpathformat: i32, vardata: super::super::System::Variant::VARIANT, ldataformat: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSecurityDescriptor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ConvertSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsd: super::super::System::Variant::VARIANT, ldataformat: i32, loutformat: i32, presult: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ConvertSecurityDescriptor: usize, + pub GetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lpathformat: i32, lformat: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lpathformat: i32, vardata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ldataformat: i32) -> ::windows_core::HRESULT, + pub ConvertSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsd: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ldataformat: i32, loutformat: i32, presult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SecurityMask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetSecurityMask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnsecuritymask: i32) -> ::windows_core::HRESULT, } @@ -6505,44 +6156,39 @@ impl IADsService { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn HostComputer(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6645,16 +6291,15 @@ impl IADsService { { (::windows_core::Interface::vtable(self).SetServiceAccountPath)(::windows_core::Interface::as_raw(self), bstrserviceaccountpath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Dependencies(&self) -> ::windows_core::Result { + pub unsafe fn Dependencies(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Dependencies)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDependencies(&self, vdependencies: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDependencies)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdependencies)).ok() + pub unsafe fn SetDependencies(&self, vdependencies: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDependencies)(::windows_core::Interface::as_raw(self), vdependencies.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6684,14 +6329,8 @@ pub struct IADsService_Vtbl { pub SetServiceAccountName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrserviceaccountname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ServiceAccountPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetServiceAccountPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrserviceaccountpath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Dependencies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Dependencies: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDependencies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdependencies: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDependencies: usize, + pub Dependencies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDependencies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdependencies: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6734,44 +6373,39 @@ impl IADsServiceOperations { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn Status(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6849,44 +6483,39 @@ impl IADsSession { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn User(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6966,44 +6595,39 @@ impl IADsSyntax { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn OleAutoDataType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7146,44 +6770,39 @@ impl IADsUser { pub unsafe fn SetInfo(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetInfo)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn Get(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result + pub unsafe fn GetEx(&self, bstrname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEx)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutEx(&self, lncontrolcode: i32, bstrname: P0, vprop: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), ::core::mem::transmute(vprop)).ok() + (::windows_core::Interface::vtable(self).base__.PutEx)(::windows_core::Interface::as_raw(self), lncontrolcode, bstrname.into_param().abi(), vprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfoEx(&self, vproperties: super::super::System::Variant::VARIANT, lnreserved: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vproperties), lnreserved).ok() + pub unsafe fn GetInfoEx(&self, vproperties: P0, lnreserved: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.GetInfoEx)(::windows_core::Interface::as_raw(self), vproperties.into_param().abi(), lnreserved).ok() } pub unsafe fn BadLoginAddress(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -7329,104 +6948,95 @@ impl IADsUser { { (::windows_core::Interface::vtable(self).SetManager)(::windows_core::Interface::as_raw(self), bstrmanager.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TelephoneHome(&self) -> ::windows_core::Result { + pub unsafe fn TelephoneHome(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TelephoneHome)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTelephoneHome(&self, vtelephonehome: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetTelephoneHome)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtelephonehome)).ok() + pub unsafe fn SetTelephoneHome(&self, vtelephonehome: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetTelephoneHome)(::windows_core::Interface::as_raw(self), vtelephonehome.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TelephoneMobile(&self) -> ::windows_core::Result { + pub unsafe fn TelephoneMobile(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TelephoneMobile)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTelephoneMobile(&self, vtelephonemobile: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetTelephoneMobile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtelephonemobile)).ok() + pub unsafe fn SetTelephoneMobile(&self, vtelephonemobile: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetTelephoneMobile)(::windows_core::Interface::as_raw(self), vtelephonemobile.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TelephoneNumber(&self) -> ::windows_core::Result { + pub unsafe fn TelephoneNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TelephoneNumber)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTelephoneNumber(&self, vtelephonenumber: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetTelephoneNumber)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtelephonenumber)).ok() + pub unsafe fn SetTelephoneNumber(&self, vtelephonenumber: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetTelephoneNumber)(::windows_core::Interface::as_raw(self), vtelephonenumber.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TelephonePager(&self) -> ::windows_core::Result { + pub unsafe fn TelephonePager(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TelephonePager)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTelephonePager(&self, vtelephonepager: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetTelephonePager)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtelephonepager)).ok() + pub unsafe fn SetTelephonePager(&self, vtelephonepager: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetTelephonePager)(::windows_core::Interface::as_raw(self), vtelephonepager.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FaxNumber(&self) -> ::windows_core::Result { + pub unsafe fn FaxNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FaxNumber)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetFaxNumber(&self, vfaxnumber: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetFaxNumber)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vfaxnumber)).ok() + pub unsafe fn SetFaxNumber(&self, vfaxnumber: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetFaxNumber)(::windows_core::Interface::as_raw(self), vfaxnumber.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OfficeLocations(&self) -> ::windows_core::Result { + pub unsafe fn OfficeLocations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).OfficeLocations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOfficeLocations(&self, vofficelocations: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOfficeLocations)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vofficelocations)).ok() + pub unsafe fn SetOfficeLocations(&self, vofficelocations: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetOfficeLocations)(::windows_core::Interface::as_raw(self), vofficelocations.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PostalAddresses(&self) -> ::windows_core::Result { + pub unsafe fn PostalAddresses(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PostalAddresses)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPostalAddresses(&self, vpostaladdresses: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPostalAddresses)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vpostaladdresses)).ok() + pub unsafe fn SetPostalAddresses(&self, vpostaladdresses: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPostalAddresses)(::windows_core::Interface::as_raw(self), vpostaladdresses.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PostalCodes(&self) -> ::windows_core::Result { + pub unsafe fn PostalCodes(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PostalCodes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPostalCodes(&self, vpostalcodes: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPostalCodes)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vpostalcodes)).ok() + pub unsafe fn SetPostalCodes(&self, vpostalcodes: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPostalCodes)(::windows_core::Interface::as_raw(self), vpostalcodes.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SeeAlso(&self) -> ::windows_core::Result { + pub unsafe fn SeeAlso(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SeeAlso)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSeeAlso(&self, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vseealso)).ok() + pub unsafe fn SetSeeAlso(&self, vseealso: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSeeAlso)(::windows_core::Interface::as_raw(self), vseealso.into_param().abi()).ok() } pub unsafe fn AccountDisabled(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7469,27 +7079,25 @@ impl IADsUser { { (::windows_core::Interface::vtable(self).SetIsAccountLocked)(::windows_core::Interface::as_raw(self), fisaccountlocked.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LoginHours(&self) -> ::windows_core::Result { + pub unsafe fn LoginHours(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LoginHours)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetLoginHours(&self, vloginhours: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetLoginHours)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vloginhours)).ok() + pub unsafe fn SetLoginHours(&self, vloginhours: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetLoginHours)(::windows_core::Interface::as_raw(self), vloginhours.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LoginWorkstations(&self) -> ::windows_core::Result { + pub unsafe fn LoginWorkstations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LoginWorkstations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetLoginWorkstations(&self, vloginworkstations: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetLoginWorkstations)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vloginworkstations)).ok() + pub unsafe fn SetLoginWorkstations(&self, vloginworkstations: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetLoginWorkstations)(::windows_core::Interface::as_raw(self), vloginworkstations.into_param().abi()).ok() } pub unsafe fn MaxLogins(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7559,16 +7167,15 @@ impl IADsUser { { (::windows_core::Interface::vtable(self).SetHomeDirectory)(::windows_core::Interface::as_raw(self), bstrhomedirectory.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Languages(&self) -> ::windows_core::Result { + pub unsafe fn Languages(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Languages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetLanguages(&self, vlanguages: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetLanguages)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vlanguages)).ok() + pub unsafe fn SetLanguages(&self, vlanguages: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetLanguages)(::windows_core::Interface::as_raw(self), vlanguages.into_param().abi()).ok() } pub unsafe fn Profile(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -7590,16 +7197,15 @@ impl IADsUser { { (::windows_core::Interface::vtable(self).SetLoginScript)(::windows_core::Interface::as_raw(self), bstrloginscript.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Picture(&self) -> ::windows_core::Result { + pub unsafe fn Picture(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Picture)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPicture(&self, vpicture: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPicture)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vpicture)).ok() + pub unsafe fn SetPicture(&self, vpicture: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPicture)(::windows_core::Interface::as_raw(self), vpicture.into_param().abi()).ok() } pub unsafe fn HomePage(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -7666,78 +7272,24 @@ pub struct IADsUser_Vtbl { pub SetTitle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Manager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetManager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmanager: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TelephoneHome: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TelephoneHome: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTelephoneHome: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonehome: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTelephoneHome: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TelephoneMobile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TelephoneMobile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTelephoneMobile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonemobile: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTelephoneMobile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TelephoneNumber: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonenumber: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTelephoneNumber: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TelephonePager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TelephonePager: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTelephonePager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonepager: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTelephonePager: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FaxNumber: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetFaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vfaxnumber: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetFaxNumber: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OfficeLocations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OfficeLocations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOfficeLocations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vofficelocations: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOfficeLocations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PostalAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PostalAddresses: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPostalAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostaladdresses: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPostalAddresses: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PostalCodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PostalCodes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPostalCodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostalcodes: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPostalCodes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SeeAlso: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSeeAlso: usize, + pub TelephoneHome: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetTelephoneHome: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonehome: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub TelephoneMobile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetTelephoneMobile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonemobile: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub TelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetTelephoneNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonenumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub TelephonePager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetTelephonePager: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtelephonepager: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub FaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetFaxNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vfaxnumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub OfficeLocations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetOfficeLocations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vofficelocations: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PostalAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPostalAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostaladdresses: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PostalCodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPostalCodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpostalcodes: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSeeAlso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vseealso: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AccountDisabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetAccountDisabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, faccountdisabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub AccountExpirationDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut f64) -> ::windows_core::HRESULT, @@ -7748,22 +7300,10 @@ pub struct IADsUser_Vtbl { pub SetGraceLoginsRemaining: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lngraceloginsremaining: i32) -> ::windows_core::HRESULT, pub IsAccountLocked: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetIsAccountLocked: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fisaccountlocked: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LoginHours: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LoginHours: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetLoginHours: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vloginhours: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetLoginHours: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LoginWorkstations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LoginWorkstations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetLoginWorkstations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vloginworkstations: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetLoginWorkstations: usize, + pub LoginHours: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetLoginHours: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vloginhours: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub LoginWorkstations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetLoginWorkstations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vloginworkstations: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MaxLogins: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, pub SetMaxLogins: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lnmaxlogins: i32) -> ::windows_core::HRESULT, pub MaxStorage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, @@ -7780,26 +7320,14 @@ pub struct IADsUser_Vtbl { pub SetEmailAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstremailaddress: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub HomeDirectory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetHomeDirectory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrhomedirectory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Languages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Languages: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vlanguages: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetLanguages: usize, + pub Languages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetLanguages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vlanguages: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Profile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetProfile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprofile: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LoginScript: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetLoginScript: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrloginscript: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Picture: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Picture: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPicture: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpicture: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPicture: usize, + pub Picture: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPicture: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vpicture: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub HomePage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetHomePage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrhomepage: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -8511,10 +8039,10 @@ impl IPrivateDispatch { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ADSIGetIDsOfNames)(::windows_core::Interface::as_raw(self), riid, rgsznames, cnames, lcid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ADSIInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ADSIInvoke)(::windows_core::Interface::as_raw(self), dispidmember, riid, lcid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ADSIInvoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ADSIInvoke)(::windows_core::Interface::as_raw(self), dispidmember, riid, lcid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } } #[repr(C)] @@ -8528,9 +8056,9 @@ pub struct IPrivateDispatch_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] ADSIGetTypeInfo: usize, pub ADSIGetIDsOfNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, rgsznames: *const *const u16, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ADSIInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ADSIInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ADSIInvoke: usize, } ::windows_core::imp::com_interface!(IPrivateUnknown, IPrivateUnknown_Vtbl, 0x89126bab_6ead_11d1_8c18_00c04fd8d503); @@ -13979,83 +13507,65 @@ impl ::core::default::Default for DS_SCHEMA_GUID_MAPW { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct DS_SELECTION { pub pwzName: ::windows_core::PWSTR, pub pwzADsPath: ::windows_core::PWSTR, pub pwzClass: ::windows_core::PWSTR, pub pwzUPN: ::windows_core::PWSTR, - pub pvarFetchedAttributes: *mut super::super::System::Variant::VARIANT, + pub pvarFetchedAttributes: *mut ::windows_core::VARIANT, pub flScopeType: u32, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for DS_SELECTION {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for DS_SELECTION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for DS_SELECTION { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("DS_SELECTION").field("pwzName", &self.pwzName).field("pwzADsPath", &self.pwzADsPath).field("pwzClass", &self.pwzClass).field("pwzUPN", &self.pwzUPN).field("pvarFetchedAttributes", &self.pvarFetchedAttributes).field("flScopeType", &self.flScopeType).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for DS_SELECTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for DS_SELECTION { fn eq(&self, other: &Self) -> bool { self.pwzName == other.pwzName && self.pwzADsPath == other.pwzADsPath && self.pwzClass == other.pwzClass && self.pwzUPN == other.pwzUPN && self.pvarFetchedAttributes == other.pvarFetchedAttributes && self.flScopeType == other.flScopeType } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for DS_SELECTION {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for DS_SELECTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct DS_SELECTION_LIST { pub cItems: u32, pub cFetchedAttributes: u32, pub aDsSelection: [DS_SELECTION; 1], } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for DS_SELECTION_LIST {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for DS_SELECTION_LIST { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for DS_SELECTION_LIST { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("DS_SELECTION_LIST").field("cItems", &self.cItems).field("cFetchedAttributes", &self.cFetchedAttributes).field("aDsSelection", &self.aDsSelection).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for DS_SELECTION_LIST { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for DS_SELECTION_LIST { fn eq(&self, other: &Self) -> bool { self.cItems == other.cItems && self.cFetchedAttributes == other.cFetchedAttributes && self.aDsSelection == other.aDsSelection } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for DS_SELECTION_LIST {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for DS_SELECTION_LIST { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/impl.rs b/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/impl.rs index 07f13ae35a..91af2ac946 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/impl.rs @@ -53,17 +53,17 @@ impl AsyncIBackgroundCopyCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBITSExtensionSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EnableBITSUploads(&self) -> ::windows_core::Result<()>; fn DisableBITSUploads(&self) -> ::windows_core::Result<()>; fn GetCleanupTaskName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetCleanupTask(&self, riid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBITSExtensionSetup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBITSExtensionSetup_Vtbl { pub const fn new, Impl: IBITSExtensionSetup_Impl, const OFFSET: isize>() -> IBITSExtensionSetup_Vtbl { unsafe extern "system" fn EnableBITSUploads, Impl: IBITSExtensionSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -110,14 +110,14 @@ impl IBITSExtensionSetup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBITSExtensionSetupFactory_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetObject(&self, path: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBITSExtensionSetupFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBITSExtensionSetupFactory_Vtbl { pub const fn new, Impl: IBITSExtensionSetupFactory_Impl, const OFFSET: isize>() -> IBITSExtensionSetupFactory_Vtbl { unsafe extern "system" fn GetObject, Impl: IBITSExtensionSetupFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppextensionsetup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -527,11 +527,9 @@ impl IBackgroundCopyFile6_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IBackgroundCopyGroup_Impl: Sized { - fn GetProp(&self, propid: GROUPPROP) -> ::windows_core::Result; - fn SetProp(&self, propid: GROUPPROP, pvarval: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProp(&self, propid: GROUPPROP) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProp(&self, propid: GROUPPROP, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetProgress(&self, dwflags: u32) -> ::windows_core::Result; fn GetStatus(&self, pdwstatus: *mut u32, pdwjobindex: *mut u32) -> ::windows_core::Result<()>; fn GetJob(&self, jobid: &::windows_core::GUID) -> ::windows_core::Result; @@ -546,12 +544,10 @@ pub trait IBackgroundCopyGroup_Impl: Sized { fn QueryNewJobInterface(&self, iid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; fn SetNotificationPointer(&self, iid: *const ::windows_core::GUID, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IBackgroundCopyGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IBackgroundCopyGroup_Vtbl { pub const fn new, Impl: IBackgroundCopyGroup_Impl, const OFFSET: isize>() -> IBackgroundCopyGroup_Vtbl { - unsafe extern "system" fn GetProp, Impl: IBackgroundCopyGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProp, Impl: IBackgroundCopyGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProp(::core::mem::transmute_copy(&propid)) { @@ -562,7 +558,7 @@ impl IBackgroundCopyGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProp, Impl: IBackgroundCopyGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProp, Impl: IBackgroundCopyGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProp(::core::mem::transmute_copy(&propid), ::core::mem::transmute_copy(&pvarval)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/mod.rs b/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/mod.rs index dd0ba26197..187a2a0146 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/BackgroundIntelligentTransferService/mod.rs @@ -571,16 +571,12 @@ pub struct IBackgroundCopyFile6_Vtbl { ::windows_core::imp::com_interface!(IBackgroundCopyGroup, IBackgroundCopyGroup_Vtbl, 0x1ded80a7_53ea_424f_8a04_17fea9adc4f5); ::windows_core::imp::interface_hierarchy!(IBackgroundCopyGroup, ::windows_core::IUnknown); impl IBackgroundCopyGroup { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProp(&self, propid: GROUPPROP) -> ::windows_core::Result { + pub unsafe fn GetProp(&self, propid: GROUPPROP) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProp)(::windows_core::Interface::as_raw(self), propid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProp(&self, propid: GROUPPROP, pvarval: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProp)(::windows_core::Interface::as_raw(self), propid, pvarval).ok() + pub unsafe fn SetProp(&self, propid: GROUPPROP, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetProp)(::windows_core::Interface::as_raw(self), propid, ::core::mem::transmute(pvarval)).ok() } pub unsafe fn GetProgress(&self, dwflags: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -636,14 +632,8 @@ impl IBackgroundCopyGroup { #[doc(hidden)] pub struct IBackgroundCopyGroup_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProp: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProp: usize, + pub GetProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: GROUPPROP, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetProgress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwflags: u32, pdwprogress: *mut u32) -> ::windows_core::HRESULT, pub GetStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwstatus: *mut u32, pdwjobindex: *mut u32) -> ::windows_core::HRESULT, pub GetJob: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, jobid: ::windows_core::GUID, ppjob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Networking/Clustering/impl.rs b/crates/libs/windows/src/Windows/Win32/Networking/Clustering/impl.rs index 6f5e261473..f728123c54 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/Clustering/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/Clustering/impl.rs @@ -206,16 +206,16 @@ impl IGetClusterUIInfo_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusApplication_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DomainNames(&self) -> ::windows_core::Result; fn get_ClusterNames(&self, bstrdomainname: &::windows_core::BSTR) -> ::windows_core::Result; fn OpenCluster(&self, bstrclustername: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusApplication_Vtbl { pub const fn new, Impl: ISClusApplication_Impl, const OFFSET: isize>() -> ISClusApplication_Vtbl { unsafe extern "system" fn DomainNames, Impl: ISClusApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdomains: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -262,19 +262,19 @@ impl ISClusApplication_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusCryptoKeys_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; fn AddItem(&self, bstrcryptokey: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusCryptoKeys {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusCryptoKeys_Vtbl { pub const fn new, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>() -> ISClusCryptoKeys_Vtbl { unsafe extern "system" fn Count, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -304,7 +304,7 @@ impl ISClusCryptoKeys_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrcyrptokey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrcyrptokey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -320,7 +320,7 @@ impl ISClusCryptoKeys_Vtbl { let this = (*this).get_impl(); this.AddItem(::core::mem::transmute(&bstrcryptokey)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusCryptoKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -339,17 +339,17 @@ impl ISClusCryptoKeys_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusDisk_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Signature(&self) -> ::windows_core::Result; fn ScsiAddress(&self) -> ::windows_core::Result; fn DiskNumber(&self) -> ::windows_core::Result; fn Partitions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusDisk {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusDisk_Vtbl { pub const fn new, Impl: ISClusDisk_Impl, const OFFSET: isize>() -> ISClusDisk_Vtbl { unsafe extern "system" fn Signature, Impl: ISClusDisk_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plsignature: *mut i32) -> ::windows_core::HRESULT { @@ -408,16 +408,16 @@ impl ISClusDisk_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusDisks_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusDisks {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusDisks_Vtbl { pub const fn new, Impl: ISClusDisks_Impl, const OFFSET: isize>() -> ISClusDisks_Vtbl { unsafe extern "system" fn Count, Impl: ISClusDisks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -442,7 +442,7 @@ impl ISClusDisks_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISClusDisks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppdisk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusDisks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdisk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -464,8 +464,8 @@ impl ISClusDisks_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNetInterface_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -476,9 +476,9 @@ pub trait ISClusNetInterface_Impl: Sized + super::super::System::Com::IDispatch_ fn State(&self) -> ::windows_core::Result; fn Cluster(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNetInterface {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNetInterface_Vtbl { pub const fn new, Impl: ISClusNetInterface_Impl, const OFFSET: isize>() -> ISClusNetInterface_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusNetInterface_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -585,17 +585,17 @@ impl ISClusNetInterface_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNetInterfaces_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNetInterfaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNetInterfaces_Vtbl { pub const fn new, Impl: ISClusNetInterfaces_Impl, const OFFSET: isize>() -> ISClusNetInterfaces_Vtbl { unsafe extern "system" fn Count, Impl: ISClusNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -625,7 +625,7 @@ impl ISClusNetInterfaces_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -648,8 +648,8 @@ impl ISClusNetInterfaces_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -663,9 +663,9 @@ pub trait ISClusNetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl fn NetInterfaces(&self) -> ::windows_core::Result; fn Cluster(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNetwork {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNetwork_Vtbl { pub const fn new, Impl: ISClusNetwork_Impl, const OFFSET: isize>() -> ISClusNetwork_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusNetwork_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -802,17 +802,17 @@ impl ISClusNetwork_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNetworkNetInterfaces_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNetworkNetInterfaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNetworkNetInterfaces_Vtbl { pub const fn new, Impl: ISClusNetworkNetInterfaces_Impl, const OFFSET: isize>() -> ISClusNetworkNetInterfaces_Vtbl { unsafe extern "system" fn Count, Impl: ISClusNetworkNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -842,7 +842,7 @@ impl ISClusNetworkNetInterfaces_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusNetworkNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusNetworkNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -865,17 +865,17 @@ impl ISClusNetworkNetInterfaces_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNetworks_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNetworks {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNetworks_Vtbl { pub const fn new, Impl: ISClusNetworks_Impl, const OFFSET: isize>() -> ISClusNetworks_Vtbl { unsafe extern "system" fn Count, Impl: ISClusNetworks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -905,7 +905,7 @@ impl ISClusNetworks_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusNetworks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusNetworks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -928,8 +928,8 @@ impl ISClusNetworks_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNode_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -946,9 +946,9 @@ pub trait ISClusNode_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Cluster(&self) -> ::windows_core::Result; fn NetInterfaces(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNode {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNode_Vtbl { pub const fn new, Impl: ISClusNode_Impl, const OFFSET: isize>() -> ISClusNode_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusNode_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1109,17 +1109,17 @@ impl ISClusNode_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNodeNetInterfaces_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNodeNetInterfaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNodeNetInterfaces_Vtbl { pub const fn new, Impl: ISClusNodeNetInterfaces_Impl, const OFFSET: isize>() -> ISClusNodeNetInterfaces_Vtbl { unsafe extern "system" fn Count, Impl: ISClusNodeNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1149,7 +1149,7 @@ impl ISClusNodeNetInterfaces_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusNodeNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusNodeNetInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -1172,17 +1172,17 @@ impl ISClusNodeNetInterfaces_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusNodes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusNodes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusNodes_Vtbl { pub const fn new, Impl: ISClusNodes_Impl, const OFFSET: isize>() -> ISClusNodes_Vtbl { unsafe extern "system" fn Count, Impl: ISClusNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1212,7 +1212,7 @@ impl ISClusNodes_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -1235,8 +1235,8 @@ impl ISClusNodes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPartition_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Flags(&self) -> ::windows_core::Result; fn DeviceName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1246,9 +1246,9 @@ pub trait ISClusPartition_Impl: Sized + super::super::System::Com::IDispatch_Imp fn FileSystemFlags(&self) -> ::windows_core::Result; fn FileSystem(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPartition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPartition_Vtbl { pub const fn new, Impl: ISClusPartition_Impl, const OFFSET: isize>() -> ISClusPartition_Vtbl { unsafe extern "system" fn Flags, Impl: ISClusPartition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plflags: *mut i32) -> ::windows_core::HRESULT { @@ -1343,8 +1343,8 @@ impl ISClusPartition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPartitionEx_Impl: Sized + ISClusPartition_Impl { fn TotalSize(&self) -> ::windows_core::Result; fn FreeSpace(&self) -> ::windows_core::Result; @@ -1352,9 +1352,9 @@ pub trait ISClusPartitionEx_Impl: Sized + ISClusPartition_Impl { fn PartitionNumber(&self) -> ::windows_core::Result; fn VolumeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPartitionEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPartitionEx_Vtbl { pub const fn new, Impl: ISClusPartitionEx_Impl, const OFFSET: isize>() -> ISClusPartitionEx_Vtbl { unsafe extern "system" fn TotalSize, Impl: ISClusPartitionEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pltotalsize: *mut i32) -> ::windows_core::HRESULT { @@ -1425,16 +1425,16 @@ impl ISClusPartitionEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPartitions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPartitions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPartitions_Vtbl { pub const fn new, Impl: ISClusPartitions_Impl, const OFFSET: isize>() -> ISClusPartitions_Vtbl { unsafe extern "system" fn Count, Impl: ISClusPartitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1459,7 +1459,7 @@ impl ISClusPartitions_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISClusPartitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pppartition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusPartitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppartition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -1481,24 +1481,24 @@ impl ISClusPartitions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusProperties_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateItem(&self, bstrname: &::windows_core::BSTR, varvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn UseDefaultValue(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SaveChanges(&self) -> ::windows_core::Result; - fn ReadOnly(&self) -> ::windows_core::Result; - fn Private(&self) -> ::windows_core::Result; - fn Common(&self) -> ::windows_core::Result; - fn Modified(&self) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateItem(&self, bstrname: &::windows_core::BSTR, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result; + fn UseDefaultValue(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SaveChanges(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ReadOnly(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Private(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Common(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusProperties_Vtbl { pub const fn new, Impl: ISClusProperties_Impl, const OFFSET: isize>() -> ISClusProperties_Vtbl { unsafe extern "system" fn Count, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1528,7 +1528,7 @@ impl ISClusProperties_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -1539,7 +1539,7 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateItem, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::System::Variant::VARIANT, pproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateItem, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateItem(::core::mem::transmute(&bstrname), ::core::mem::transmute(&varvalue)) { @@ -1550,12 +1550,12 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn UseDefaultValue, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UseDefaultValue, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.UseDefaultValue(::core::mem::transmute(&varindex)).into() } - unsafe extern "system" fn SaveChanges, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarstatuscode: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SaveChanges, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarstatuscode: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SaveChanges() { @@ -1566,7 +1566,7 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReadOnly, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreadonly: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadOnly, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreadonly: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReadOnly() { @@ -1577,7 +1577,7 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Private, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprivate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Private, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprivate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Private() { @@ -1588,7 +1588,7 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Common, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcommon: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Common, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcommon: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Common() { @@ -1599,7 +1599,7 @@ impl ISClusProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Modified, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Modified, Impl: ISClusProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Modified() { @@ -1629,28 +1629,28 @@ impl ISClusProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusProperty_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Length(&self) -> ::windows_core::Result; fn ValueCount(&self) -> ::windows_core::Result; fn Values(&self) -> ::windows_core::Result; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, varvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Type(&self) -> ::windows_core::Result; fn SetType(&self, r#type: CLUSTER_PROPERTY_TYPE) -> ::windows_core::Result<()>; fn Format(&self) -> ::windows_core::Result; fn SetFormat(&self, format: CLUSTER_PROPERTY_FORMAT) -> ::windows_core::Result<()>; - fn ReadOnly(&self) -> ::windows_core::Result; - fn Private(&self) -> ::windows_core::Result; - fn Common(&self) -> ::windows_core::Result; - fn Modified(&self) -> ::windows_core::Result; + fn ReadOnly(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Private(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Common(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn UseDefaultValue(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusProperty_Vtbl { pub const fn new, Impl: ISClusProperty_Impl, const OFFSET: isize>() -> ISClusProperty_Vtbl { unsafe extern "system" fn Name, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1697,7 +1697,7 @@ impl ISClusProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -1708,7 +1708,7 @@ impl ISClusProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&varvalue)).into() @@ -1745,7 +1745,7 @@ impl ISClusProperty_Vtbl { let this = (*this).get_impl(); this.SetFormat(::core::mem::transmute_copy(&format)).into() } - unsafe extern "system" fn ReadOnly, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreadonly: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadOnly, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreadonly: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReadOnly() { @@ -1756,7 +1756,7 @@ impl ISClusProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Private, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprivate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Private, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprivate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Private() { @@ -1767,7 +1767,7 @@ impl ISClusProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Common, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcommon: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Common, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcommon: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Common() { @@ -1778,7 +1778,7 @@ impl ISClusProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Modified, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Modified, Impl: ISClusProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Modified() { @@ -1817,11 +1817,11 @@ impl ISClusProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPropertyValue_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, varvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Type(&self) -> ::windows_core::Result; fn SetType(&self, r#type: CLUSTER_PROPERTY_TYPE) -> ::windows_core::Result<()>; fn Format(&self) -> ::windows_core::Result; @@ -1830,12 +1830,12 @@ pub trait ISClusPropertyValue_Impl: Sized + super::super::System::Com::IDispatch fn DataCount(&self) -> ::windows_core::Result; fn Data(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPropertyValue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPropertyValue_Vtbl { pub const fn new, Impl: ISClusPropertyValue_Impl, const OFFSET: isize>() -> ISClusPropertyValue_Vtbl { - unsafe extern "system" fn Value, Impl: ISClusPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISClusPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -1846,7 +1846,7 @@ impl ISClusPropertyValue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISClusPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISClusPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&varvalue)).into() @@ -1933,18 +1933,18 @@ impl ISClusPropertyValue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPropertyValueData_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateItem(&self, varvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CreateItem(&self, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPropertyValueData {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPropertyValueData_Vtbl { pub const fn new, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>() -> ISClusPropertyValueData_Vtbl { unsafe extern "system" fn Count, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -1969,7 +1969,7 @@ impl ISClusPropertyValueData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -1980,7 +1980,7 @@ impl ISClusPropertyValueData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateItem, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT, pvardata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateItem, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvardata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateItem(::core::mem::transmute(&varvalue)) { @@ -1991,7 +1991,7 @@ impl ISClusPropertyValueData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RemoveItem, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusPropertyValueData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -2009,18 +2009,18 @@ impl ISClusPropertyValueData_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusPropertyValues_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateItem(&self, bstrname: &::windows_core::BSTR, varvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateItem(&self, bstrname: &::windows_core::BSTR, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusPropertyValues {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusPropertyValues_Vtbl { pub const fn new, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>() -> ISClusPropertyValues_Vtbl { unsafe extern "system" fn Count, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2045,7 +2045,7 @@ impl ISClusPropertyValues_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2056,7 +2056,7 @@ impl ISClusPropertyValues_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateItem, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::System::Variant::VARIANT, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateItem, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateItem(::core::mem::transmute(&bstrname), ::core::mem::transmute(&varvalue)) { @@ -2067,7 +2067,7 @@ impl ISClusPropertyValues_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RemoveItem, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusPropertyValues_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -2085,14 +2085,14 @@ impl ISClusPropertyValues_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusRefObject_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusRefObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusRefObject_Vtbl { pub const fn new, Impl: ISClusRefObject_Impl, const OFFSET: isize>() -> ISClusRefObject_Vtbl { unsafe extern "system" fn Handle, Impl: ISClusRefObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phandle: *mut usize) -> ::windows_core::HRESULT { @@ -2112,19 +2112,19 @@ impl ISClusRefObject_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusRegistryKeys_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; fn AddItem(&self, bstrregistrykey: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusRegistryKeys {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusRegistryKeys_Vtbl { pub const fn new, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>() -> ISClusRegistryKeys_Vtbl { unsafe extern "system" fn Count, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2154,7 +2154,7 @@ impl ISClusRegistryKeys_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrregistrykey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrregistrykey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2170,7 +2170,7 @@ impl ISClusRegistryKeys_Vtbl { let this = (*this).get_impl(); this.AddItem(::core::mem::transmute(&bstrregistrykey)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusRegistryKeys_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -2189,21 +2189,21 @@ impl ISClusRegistryKeys_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResDependencies_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcename: &::windows_core::BSTR, bstrresourcetype: &::windows_core::BSTR, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AddItem(&self, presource: ::core::option::Option<&ISClusResource>) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResDependencies {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResDependencies_Vtbl { pub const fn new, Impl: ISClusResDependencies_Impl, const OFFSET: isize>() -> ISClusResDependencies_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2233,7 +2233,7 @@ impl ISClusResDependencies_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2255,7 +2255,7 @@ impl ISClusResDependencies_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -2265,7 +2265,7 @@ impl ISClusResDependencies_Vtbl { let this = (*this).get_impl(); this.AddItem(::windows_core::from_raw_borrowed(&presource)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusResDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -2286,21 +2286,21 @@ impl ISClusResDependencies_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResDependents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcename: &::windows_core::BSTR, bstrresourcetype: &::windows_core::BSTR, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AddItem(&self, presource: ::core::option::Option<&ISClusResource>) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResDependents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResDependents_Vtbl { pub const fn new, Impl: ISClusResDependents_Impl, const OFFSET: isize>() -> ISClusResDependents_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2330,7 +2330,7 @@ impl ISClusResDependents_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2352,7 +2352,7 @@ impl ISClusResDependents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -2362,7 +2362,7 @@ impl ISClusResDependents_Vtbl { let this = (*this).get_impl(); this.AddItem(::windows_core::from_raw_borrowed(&presource)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusResDependents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() @@ -2383,8 +2383,8 @@ impl ISClusResDependents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResGroup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -2398,14 +2398,14 @@ pub trait ISClusResGroup_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Resources(&self) -> ::windows_core::Result; fn PreferredOwnerNodes(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; - fn Online(&self, vartimeout: &super::super::System::Variant::VARIANT, varnode: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Move(&self, vartimeout: &super::super::System::Variant::VARIANT, varnode: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Offline(&self, vartimeout: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Online(&self, vartimeout: &::windows_core::VARIANT, varnode: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Move(&self, vartimeout: &::windows_core::VARIANT, varnode: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Offline(&self, vartimeout: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; fn Cluster(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResGroup_Vtbl { pub const fn new, Impl: ISClusResGroup_Impl, const OFFSET: isize>() -> ISClusResGroup_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2528,7 +2528,7 @@ impl ISClusResGroup_Vtbl { let this = (*this).get_impl(); this.Delete().into() } - unsafe extern "system" fn Online, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Online, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varnode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Online(::core::mem::transmute(&vartimeout), ::core::mem::transmute(&varnode)) { @@ -2539,7 +2539,7 @@ impl ISClusResGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Move, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Move, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varnode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Move(::core::mem::transmute(&vartimeout), ::core::mem::transmute(&varnode)) { @@ -2550,7 +2550,7 @@ impl ISClusResGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Offline, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Offline, Impl: ISClusResGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Offline(::core::mem::transmute(&vartimeout)) { @@ -2596,22 +2596,22 @@ impl ISClusResGroup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResGroupPreferredOwnerNodes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn InsertItem(&self, pnode: ::core::option::Option<&ISClusNode>, nposition: i32) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Modified(&self) -> ::windows_core::Result; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SaveChanges(&self) -> ::windows_core::Result<()>; fn AddItem(&self, pnode: ::core::option::Option<&ISClusNode>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResGroupPreferredOwnerNodes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResGroupPreferredOwnerNodes_Vtbl { pub const fn new, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>() -> ISClusResGroupPreferredOwnerNodes_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2641,7 +2641,7 @@ impl ISClusResGroupPreferredOwnerNodes_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2657,12 +2657,12 @@ impl ISClusResGroupPreferredOwnerNodes_Vtbl { let this = (*this).get_impl(); this.InsertItem(::windows_core::from_raw_borrowed(&pnode), ::core::mem::transmute_copy(&nposition)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() } - unsafe extern "system" fn Modified, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Modified, Impl: ISClusResGroupPreferredOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Modified() { @@ -2700,19 +2700,19 @@ impl ISClusResGroupPreferredOwnerNodes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResGroupResources_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcename: &::windows_core::BSTR, bstrresourcetype: &::windows_core::BSTR, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResGroupResources {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResGroupResources_Vtbl { pub const fn new, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>() -> ISClusResGroupResources_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2742,7 +2742,7 @@ impl ISClusResGroupResources_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2764,7 +2764,7 @@ impl ISClusResGroupResources_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResGroupResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -2783,19 +2783,19 @@ impl ISClusResGroupResources_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResGroups_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcegroupname: &::windows_core::BSTR) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResGroups {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResGroups_Vtbl { pub const fn new, Impl: ISClusResGroups_Impl, const OFFSET: isize>() -> ISClusResGroups_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2825,7 +2825,7 @@ impl ISClusResGroups_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2847,7 +2847,7 @@ impl ISClusResGroups_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -2866,20 +2866,20 @@ impl ISClusResGroups_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResPossibleOwnerNodes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn AddItem(&self, pnode: ::core::option::Option<&ISClusNode>) -> ::windows_core::Result<()>; - fn RemoveItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Modified(&self) -> ::windows_core::Result; + fn RemoveItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResPossibleOwnerNodes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResPossibleOwnerNodes_Vtbl { pub const fn new, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>() -> ISClusResPossibleOwnerNodes_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2909,7 +2909,7 @@ impl ISClusResPossibleOwnerNodes_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -2925,12 +2925,12 @@ impl ISClusResPossibleOwnerNodes_Vtbl { let this = (*this).get_impl(); this.AddItem(::windows_core::from_raw_borrowed(&pnode)).into() } - unsafe extern "system" fn RemoveItem, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RemoveItem, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RemoveItem(::core::mem::transmute(&varindex)).into() } - unsafe extern "system" fn Modified, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Modified, Impl: ISClusResPossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Modified() { @@ -2956,8 +2956,8 @@ impl ISClusResPossibleOwnerNodes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResType_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -2970,9 +2970,9 @@ pub trait ISClusResType_Impl: Sized + super::super::System::Com::IDispatch_Impl fn PossibleOwnerNodes(&self) -> ::windows_core::Result; fn AvailableDisks(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResType {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResType_Vtbl { pub const fn new, Impl: ISClusResType_Impl, const OFFSET: isize>() -> ISClusResType_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusResType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3097,17 +3097,17 @@ impl ISClusResType_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResTypePossibleOwnerNodes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResTypePossibleOwnerNodes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResTypePossibleOwnerNodes_Vtbl { pub const fn new, Impl: ISClusResTypePossibleOwnerNodes_Impl, const OFFSET: isize>() -> ISClusResTypePossibleOwnerNodes_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResTypePossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -3137,7 +3137,7 @@ impl ISClusResTypePossibleOwnerNodes_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResTypePossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResTypePossibleOwnerNodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -3160,19 +3160,19 @@ impl ISClusResTypePossibleOwnerNodes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResTypeResources_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcename: &::windows_core::BSTR, bstrgroupname: &::windows_core::BSTR, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResTypeResources {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResTypeResources_Vtbl { pub const fn new, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>() -> ISClusResTypeResources_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -3202,7 +3202,7 @@ impl ISClusResTypeResources_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -3224,7 +3224,7 @@ impl ISClusResTypeResources_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResTypeResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -3243,19 +3243,19 @@ impl ISClusResTypeResources_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResTypes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcetypename: &::windows_core::BSTR, bstrdisplayname: &::windows_core::BSTR, bstrresourcetypedll: &::windows_core::BSTR, dwlooksalivepollinterval: i32, dwisalivepollinterval: i32) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResTypes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResTypes_Vtbl { pub const fn new, Impl: ISClusResTypes_Impl, const OFFSET: isize>() -> ISClusResTypes_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -3285,7 +3285,7 @@ impl ISClusResTypes_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusrestype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusrestype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -3307,7 +3307,7 @@ impl ISClusResTypes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResTypes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -3326,8 +3326,8 @@ impl ISClusResTypes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResource_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -3341,12 +3341,12 @@ pub trait ISClusResource_Impl: Sized + super::super::System::Com::IDispatch_Impl fn BecomeQuorumResource(&self, bstrdevicepath: &::windows_core::BSTR, lmaxlogsize: i32) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; fn Fail(&self) -> ::windows_core::Result<()>; - fn Online(&self, ntimeout: i32) -> ::windows_core::Result; - fn Offline(&self, ntimeout: i32) -> ::windows_core::Result; + fn Online(&self, ntimeout: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Offline(&self, ntimeout: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn ChangeResourceGroup(&self, presourcegroup: ::core::option::Option<&ISClusResGroup>) -> ::windows_core::Result<()>; fn AddResourceNode(&self, pnode: ::core::option::Option<&ISClusNode>) -> ::windows_core::Result<()>; fn RemoveResourceNode(&self, pnode: ::core::option::Option<&ISClusNode>) -> ::windows_core::Result<()>; - fn CanResourceBeDependent(&self, presource: ::core::option::Option<&ISClusResource>) -> ::windows_core::Result; + fn CanResourceBeDependent(&self, presource: ::core::option::Option<&ISClusResource>) -> ::windows_core::Result<::windows_core::VARIANT>; fn PossibleOwnerNodes(&self) -> ::windows_core::Result; fn Dependencies(&self) -> ::windows_core::Result; fn Dependents(&self) -> ::windows_core::Result; @@ -3362,9 +3362,9 @@ pub trait ISClusResource_Impl: Sized + super::super::System::Com::IDispatch_Impl fn MaintenanceMode(&self) -> ::windows_core::Result; fn SetMaintenanceMode(&self, bmaintenancemode: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResource {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResource_Vtbl { pub const fn new, Impl: ISClusResource_Impl, const OFFSET: isize>() -> ISClusResource_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3475,7 +3475,7 @@ impl ISClusResource_Vtbl { let this = (*this).get_impl(); this.Fail().into() } - unsafe extern "system" fn Online, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Online, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Online(::core::mem::transmute_copy(&ntimeout)) { @@ -3486,7 +3486,7 @@ impl ISClusResource_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Offline, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Offline, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Offline(::core::mem::transmute_copy(&ntimeout)) { @@ -3512,7 +3512,7 @@ impl ISClusResource_Vtbl { let this = (*this).get_impl(); this.RemoveResourceNode(::windows_core::from_raw_borrowed(&pnode)).into() } - unsafe extern "system" fn CanResourceBeDependent, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void, pvardependent: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CanResourceBeDependent, Impl: ISClusResource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void, pvardependent: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CanResourceBeDependent(::windows_core::from_raw_borrowed(&presource)) { @@ -3711,19 +3711,19 @@ impl ISClusResource_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusResources_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateItem(&self, bstrresourcename: &::windows_core::BSTR, bstrresourcetype: &::windows_core::BSTR, bstrgroupname: &::windows_core::BSTR, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS) -> ::windows_core::Result; - fn DeleteItem(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteItem(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusResources {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusResources_Vtbl { pub const fn new, Impl: ISClusResources_Impl, const OFFSET: isize>() -> ISClusResources_Vtbl { unsafe extern "system" fn Count, Impl: ISClusResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -3753,7 +3753,7 @@ impl ISClusResources_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -3775,7 +3775,7 @@ impl ISClusResources_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteItem, Impl: ISClusResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteItem, Impl: ISClusResources_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteItem(::core::mem::transmute(&varindex)).into() @@ -3794,20 +3794,20 @@ impl ISClusResources_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusScsiAddress_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn PortNumber(&self) -> ::windows_core::Result; - fn PathId(&self) -> ::windows_core::Result; - fn TargetId(&self) -> ::windows_core::Result; - fn Lun(&self) -> ::windows_core::Result; + fn PortNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PathId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn TargetId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Lun(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusScsiAddress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusScsiAddress_Vtbl { pub const fn new, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>() -> ISClusScsiAddress_Vtbl { - unsafe extern "system" fn PortNumber, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarportnumber: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PortNumber, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarportnumber: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PortNumber() { @@ -3818,7 +3818,7 @@ impl ISClusScsiAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PathId, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarpathid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PathId, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarpathid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PathId() { @@ -3829,7 +3829,7 @@ impl ISClusScsiAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn TargetId, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvartargetid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TargetId, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvartargetid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TargetId() { @@ -3840,7 +3840,7 @@ impl ISClusScsiAddress_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Lun, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlun: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Lun, Impl: ISClusScsiAddress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlun: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Lun() { @@ -3863,8 +3863,8 @@ impl ISClusScsiAddress_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusVersion_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn MajorVersion(&self) -> ::windows_core::Result; @@ -3875,11 +3875,11 @@ pub trait ISClusVersion_Impl: Sized + super::super::System::Com::IDispatch_Impl fn ClusterHighestVersion(&self) -> ::windows_core::Result; fn ClusterLowestVersion(&self) -> ::windows_core::Result; fn Flags(&self) -> ::windows_core::Result; - fn MixedVersion(&self) -> ::windows_core::Result; + fn MixedVersion(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusVersion {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusVersion_Vtbl { pub const fn new, Impl: ISClusVersion_Impl, const OFFSET: isize>() -> ISClusVersion_Vtbl { unsafe extern "system" fn Name, Impl: ISClusVersion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrclustername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3981,7 +3981,7 @@ impl ISClusVersion_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MixedVersion, Impl: ISClusVersion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmixedversion: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn MixedVersion, Impl: ISClusVersion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmixedversion: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MixedVersion() { @@ -4010,8 +4010,8 @@ impl ISClusVersion_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISCluster_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CommonProperties(&self) -> ::windows_core::Result; fn PrivateProperties(&self) -> ::windows_core::Result; @@ -4035,9 +4035,9 @@ pub trait ISCluster_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Networks(&self) -> ::windows_core::Result; fn NetInterfaces(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISCluster {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISCluster_Vtbl { pub const fn new, Impl: ISCluster_Impl, const OFFSET: isize>() -> ISCluster_Vtbl { unsafe extern "system" fn CommonProperties, Impl: ISCluster_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4270,18 +4270,18 @@ impl ISCluster_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISClusterNames_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; fn DomainName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISClusterNames {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISClusterNames_Vtbl { pub const fn new, Impl: ISClusterNames_Impl, const OFFSET: isize>() -> ISClusterNames_Vtbl { unsafe extern "system" fn Count, Impl: ISClusterNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4311,7 +4311,7 @@ impl ISClusterNames_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISClusterNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrclustername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISClusterNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrclustername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { @@ -4346,17 +4346,17 @@ impl ISClusterNames_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISDomainNames_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn get_Item(&self, varindex: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_Item(&self, varindex: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISDomainNames {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISDomainNames_Vtbl { pub const fn new, Impl: ISDomainNames_Impl, const OFFSET: isize>() -> ISDomainNames_Vtbl { unsafe extern "system" fn Count, Impl: ISDomainNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4386,7 +4386,7 @@ impl ISDomainNames_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn get_Item, Impl: ISDomainNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrdomainname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISDomainNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrdomainname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&varindex)) { diff --git a/crates/libs/windows/src/Windows/Win32/Networking/Clustering/mod.rs b/crates/libs/windows/src/Windows/Win32/Networking/Clustering/mod.rs index 7a6e6d2c13..f6d48e03cf 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/Clustering/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/Clustering/mod.rs @@ -3779,11 +3779,12 @@ impl ISClusCryptoKeys { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn AddItem(&self, bstrcryptokey: P0) -> ::windows_core::Result<()> where @@ -3791,10 +3792,11 @@ impl ISClusCryptoKeys { { (::windows_core::Interface::vtable(self).AddItem)(::windows_core::Interface::as_raw(self), bstrcryptokey.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3805,15 +3807,9 @@ pub struct ISClusCryptoKeys_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrcyrptokey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrcyrptokey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcryptokey: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3882,11 +3878,14 @@ impl ISClusDisks { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3896,9 +3895,9 @@ pub struct ISClusDisks_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppdisk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdisk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4006,11 +4005,14 @@ impl ISClusNetInterfaces { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4021,9 +4023,9 @@ pub struct ISClusNetInterfaces_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4153,11 +4155,14 @@ impl ISClusNetworkNetInterfaces { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4168,9 +4173,9 @@ pub struct ISClusNetworkNetInterfaces_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4195,11 +4200,14 @@ impl ISClusNetworks { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4210,9 +4218,9 @@ pub struct ISClusNetworks_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4357,11 +4365,14 @@ impl ISClusNodeNetInterfaces { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4372,9 +4383,9 @@ pub struct ISClusNodeNetInterfaces_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusnetinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4399,11 +4410,14 @@ impl ISClusNodes { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4414,9 +4428,9 @@ pub struct ISClusNodes_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4562,11 +4576,14 @@ impl ISClusPartitions { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4576,9 +4593,9 @@ pub struct ISClusPartitions_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pppartition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppartition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4603,53 +4620,48 @@ impl ISClusProperties { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateItem(&self, bstrname: P0, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateItem(&self, bstrname: P0, varvalue: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(varvalue), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), varvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UseDefaultValue(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).UseDefaultValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn UseDefaultValue(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).UseDefaultValue)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SaveChanges(&self) -> ::windows_core::Result { + pub unsafe fn SaveChanges(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SaveChanges)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReadOnly(&self) -> ::windows_core::Result { + pub unsafe fn ReadOnly(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ReadOnly)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Private(&self) -> ::windows_core::Result { + pub unsafe fn Private(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Private)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Common(&self) -> ::windows_core::Result { + pub unsafe fn Common(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Common)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Modified(&self) -> ::windows_core::Result { + pub unsafe fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Modified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4662,38 +4674,20 @@ pub struct ISClusProperties_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::System::Variant::VARIANT, pproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UseDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UseDefaultValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SaveChanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarstatuscode: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SaveChanges: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReadOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreadonly: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ReadOnly: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Private: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprivate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Private: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Common: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcommon: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Common: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Modified: usize, + pub UseDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SaveChanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarstatuscode: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ReadOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreadonly: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Private: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprivate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Common: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcommon: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4724,16 +4718,15 @@ impl ISClusProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Values)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() + pub unsafe fn SetValue(&self, varvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi()).ok() } pub unsafe fn Type(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4749,27 +4742,19 @@ impl ISClusProperty { pub unsafe fn SetFormat(&self, format: CLUSTER_PROPERTY_FORMAT) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetFormat)(::windows_core::Interface::as_raw(self), format).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReadOnly(&self) -> ::windows_core::Result { + pub unsafe fn ReadOnly(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ReadOnly)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Private(&self) -> ::windows_core::Result { + pub unsafe fn Private(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Private)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Common(&self) -> ::windows_core::Result { + pub unsafe fn Common(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Common)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Modified(&self) -> ::windows_core::Result { + pub unsafe fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Modified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4789,34 +4774,16 @@ pub struct ISClusProperty_Vtbl { pub Values: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppclusterpropertyvalues: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Values: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Type: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptype: *mut CLUSTER_PROPERTY_TYPE) -> ::windows_core::HRESULT, pub SetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: CLUSTER_PROPERTY_TYPE) -> ::windows_core::HRESULT, pub Format: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pformat: *mut CLUSTER_PROPERTY_FORMAT) -> ::windows_core::HRESULT, pub SetFormat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, format: CLUSTER_PROPERTY_FORMAT) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReadOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreadonly: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ReadOnly: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Private: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprivate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Private: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Common: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcommon: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Common: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Modified: usize, + pub ReadOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreadonly: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Private: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprivate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Common: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcommon: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub UseDefaultValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -4830,16 +4797,15 @@ pub struct ISClusProperty_Vtbl { ::windows_core::imp::interface_hierarchy!(ISClusPropertyValue, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISClusPropertyValue { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() + pub unsafe fn SetValue(&self, varvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi()).ok() } pub unsafe fn Type(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4875,14 +4841,8 @@ impl ISClusPropertyValue { #[doc(hidden)] pub struct ISClusPropertyValue_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Type: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptype: *mut CLUSTER_PROPERTY_TYPE) -> ::windows_core::HRESULT, pub SetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: CLUSTER_PROPERTY_TYPE) -> ::windows_core::HRESULT, pub Format: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pformat: *mut CLUSTER_PROPERTY_FORMAT) -> ::windows_core::HRESULT, @@ -4913,22 +4873,25 @@ impl ISClusPropertyValueData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateItem(&self, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreateItem(&self, varvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), varvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4938,18 +4901,9 @@ pub struct ISClusPropertyValueData_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: super::super::System::Variant::VARIANT, pvardata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvardata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4970,25 +4924,30 @@ impl ISClusPropertyValues { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateItem(&self, bstrname: P0, varvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateItem(&self, bstrname: P0, varvalue: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(varvalue), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), varvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4998,18 +4957,15 @@ pub struct ISClusPropertyValues_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: super::super::System::Variant::VARIANT, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pppropertyvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5056,11 +5012,12 @@ impl ISClusRegistryKeys { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn AddItem(&self, bstrregistrykey: P0) -> ::windows_core::Result<()> where @@ -5068,10 +5025,11 @@ impl ISClusRegistryKeys { { (::windows_core::Interface::vtable(self).AddItem)(::windows_core::Interface::as_raw(self), bstrregistrykey.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5082,15 +5040,9 @@ pub struct ISClusRegistryKeys_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrregistrykey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrregistrykey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrregistrykey: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5114,11 +5066,14 @@ impl ISClusResDependencies { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5130,10 +5085,11 @@ impl ISClusResDependencies { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcename.into_param().abi(), bstrresourcetype.into_param().abi(), dwflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5143,10 +5099,11 @@ impl ISClusResDependencies { { (::windows_core::Interface::vtable(self).AddItem)(::windows_core::Interface::as_raw(self), presource.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5157,26 +5114,20 @@ pub struct ISClusResDependencies_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrresourcetype: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS, ppclusterresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5200,11 +5151,14 @@ impl ISClusResDependents { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5216,10 +5170,11 @@ impl ISClusResDependents { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcename.into_param().abi(), bstrresourcetype.into_param().abi(), dwflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5229,10 +5184,11 @@ impl ISClusResDependents { { (::windows_core::Interface::vtable(self).AddItem)(::windows_core::Interface::as_raw(self), presource.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5243,26 +5199,20 @@ pub struct ISClusResDependents_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrresourcetype: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS, ppclusterresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5338,23 +5288,28 @@ impl ISClusResGroup { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Online(&self, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Online(&self, vartimeout: P0, varnode: P1) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Online)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartimeout), ::core::mem::transmute(varnode), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Online)(::windows_core::Interface::as_raw(self), vartimeout.into_param().abi(), varnode.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Move(&self, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Move(&self, vartimeout: P0, varnode: P1) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Move)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartimeout), ::core::mem::transmute(varnode), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Move)(::windows_core::Interface::as_raw(self), vartimeout.into_param().abi(), varnode.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Offline(&self, vartimeout: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Offline(&self, vartimeout: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Offline)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartimeout), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Offline)(::windows_core::Interface::as_raw(self), vartimeout.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5401,18 +5356,9 @@ pub struct ISClusResGroup_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] PreferredOwnerNodes: usize, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Online: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Online: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Move: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, varnode: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Move: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Offline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: super::super::System::Variant::VARIANT, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Offline: usize, + pub Online: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varnode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Move: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varnode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Offline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartimeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Cluster: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcluster: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -5440,11 +5386,14 @@ impl ISClusResGroupPreferredOwnerNodes { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5454,14 +5403,13 @@ impl ISClusResGroupPreferredOwnerNodes { { (::windows_core::Interface::vtable(self).InsertItem)(::windows_core::Interface::as_raw(self), pnode.into_param().abi(), nposition).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Modified(&self) -> ::windows_core::Result { + pub unsafe fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Modified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5485,22 +5433,16 @@ pub struct ISClusResGroupPreferredOwnerNodes_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub InsertItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnode: *mut ::core::ffi::c_void, nposition: i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] InsertItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Modified: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SaveChanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnode: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5529,11 +5471,14 @@ impl ISClusResGroupResources { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5545,10 +5490,11 @@ impl ISClusResGroupResources { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcename.into_param().abi(), bstrresourcetype.into_param().abi(), dwflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5559,18 +5505,15 @@ pub struct ISClusResGroupResources_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrresourcetype: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS, ppclusterresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5594,11 +5537,14 @@ impl ISClusResGroups { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5609,10 +5555,11 @@ impl ISClusResGroups { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcegroupname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5623,18 +5570,15 @@ pub struct ISClusResGroups_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcegroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppresourcegroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5658,11 +5602,14 @@ impl ISClusResPossibleOwnerNodes { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5672,14 +5619,13 @@ impl ISClusResPossibleOwnerNodes { { (::windows_core::Interface::vtable(self).AddItem)(::windows_core::Interface::as_raw(self), pnode.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RemoveItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn RemoveItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RemoveItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Modified(&self) -> ::windows_core::Result { + pub unsafe fn Modified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Modified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5692,22 +5638,16 @@ pub struct ISClusResPossibleOwnerNodes_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub AddItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnode: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RemoveItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Modified: usize, + pub RemoveItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5838,11 +5778,14 @@ impl ISClusResTypePossibleOwnerNodes { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -5853,9 +5796,9 @@ pub struct ISClusResTypePossibleOwnerNodes_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppnode: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -5880,11 +5823,14 @@ impl ISClusResTypeResources { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5896,10 +5842,11 @@ impl ISClusResTypeResources { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcename.into_param().abi(), bstrgroupname.into_param().abi(), dwflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5910,18 +5857,15 @@ pub struct ISClusResTypeResources_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS, ppclusterresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5945,11 +5889,14 @@ impl ISClusResTypes { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5962,10 +5909,11 @@ impl ISClusResTypes { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcetypename.into_param().abi(), bstrdisplayname.into_param().abi(), bstrresourcetypedll.into_param().abi(), dwlooksalivepollinterval, dwisalivepollinterval, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5976,18 +5924,15 @@ pub struct ISClusResTypes_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusrestype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusrestype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcetypename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdisplayname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrresourcetypedll: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwlooksalivepollinterval: i32, dwisalivepollinterval: i32, ppresourcetype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6058,15 +6003,11 @@ impl ISClusResource { pub unsafe fn Fail(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Fail)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Online(&self, ntimeout: i32) -> ::windows_core::Result { + pub unsafe fn Online(&self, ntimeout: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Online)(::windows_core::Interface::as_raw(self), ntimeout, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Offline(&self, ntimeout: i32) -> ::windows_core::Result { + pub unsafe fn Offline(&self, ntimeout: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Offline)(::windows_core::Interface::as_raw(self), ntimeout, &mut result__).from_abi(result__) } @@ -6094,9 +6035,9 @@ impl ISClusResource { { (::windows_core::Interface::vtable(self).RemoveResourceNode)(::windows_core::Interface::as_raw(self), pnode.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanResourceBeDependent(&self, presource: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CanResourceBeDependent(&self, presource: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -6211,14 +6152,8 @@ pub struct ISClusResource_Vtbl { pub BecomeQuorumResource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdevicepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmaxlogsize: i32) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Fail: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Online: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Online: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Offline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Offline: usize, + pub Online: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Offline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ntimeout: i32, pvarpending: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub ChangeResourceGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presourcegroup: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -6231,9 +6166,9 @@ pub struct ISClusResource_Vtbl { pub RemoveResourceNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnode: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] RemoveResourceNode: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CanResourceBeDependent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void, pvardependent: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CanResourceBeDependent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, presource: *mut ::core::ffi::c_void, pvardependent: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CanResourceBeDependent: usize, #[cfg(feature = "Win32_System_Com")] pub PossibleOwnerNodes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppownernodes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -6302,11 +6237,14 @@ impl ISClusResources { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6319,10 +6257,11 @@ impl ISClusResources { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateItem)(::windows_core::Interface::as_raw(self), bstrresourcename.into_param().abi(), bstrresourcetype.into_param().abi(), bstrgroupname.into_param().abi(), dwflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteItem(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex)).ok() + pub unsafe fn DeleteItem(&self, varindex: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteItem)(::windows_core::Interface::as_raw(self), varindex.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6333,18 +6272,15 @@ pub struct ISClusResources_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclusresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrresourcename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrresourcetype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwflags: CLUSTER_RESOURCE_CREATE_FLAGS, ppclusterresource: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] CreateItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteItem: usize, + pub DeleteItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6357,27 +6293,19 @@ pub struct ISClusResources_Vtbl { ::windows_core::imp::interface_hierarchy!(ISClusScsiAddress, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISClusScsiAddress { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PortNumber(&self) -> ::windows_core::Result { + pub unsafe fn PortNumber(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PortNumber)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PathId(&self) -> ::windows_core::Result { + pub unsafe fn PathId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PathId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TargetId(&self) -> ::windows_core::Result { + pub unsafe fn TargetId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TargetId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Lun(&self) -> ::windows_core::Result { + pub unsafe fn Lun(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Lun)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6387,22 +6315,10 @@ impl ISClusScsiAddress { #[doc(hidden)] pub struct ISClusScsiAddress_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PortNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarportnumber: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PortNumber: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PathId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarpathid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PathId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TargetId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvartargetid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TargetId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Lun: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlun: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Lun: usize, + pub PortNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarportnumber: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PathId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarpathid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub TargetId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvartargetid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Lun: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlun: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6451,9 +6367,7 @@ impl ISClusVersion { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Flags)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MixedVersion(&self) -> ::windows_core::Result { + pub unsafe fn MixedVersion(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MixedVersion)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6472,10 +6386,7 @@ pub struct ISClusVersion_Vtbl { pub ClusterHighestVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnclusterhighestversion: *mut i32) -> ::windows_core::HRESULT, pub ClusterLowestVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnclusterlowestversion: *mut i32) -> ::windows_core::HRESULT, pub Flags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pnflags: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MixedVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmixedversion: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MixedVersion: usize, + pub MixedVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmixedversion: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6694,11 +6605,12 @@ impl ISClusterNames { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn DomainName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6713,10 +6625,7 @@ pub struct ISClusterNames_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrclustername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrclustername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub DomainName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdomainname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -6741,11 +6650,12 @@ impl ISDomainNames { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, varindex: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_Item(&self, varindex: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varindex), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), varindex.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -6756,10 +6666,7 @@ pub struct ISDomainNames_Vtbl { pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: super::super::System::Variant::VARIANT, pbstrdomainname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varindex: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrdomainname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWCContextMenuCallback, IWCContextMenuCallback_Vtbl, 0x97dede64_fc6b_11cf_b5f5_00a0c90ab505); ::windows_core::imp::interface_hierarchy!(IWCContextMenuCallback, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/Networking/NetworkListManager/impl.rs b/crates/libs/windows/src/Windows/Win32/Networking/NetworkListManager/impl.rs index e50e2bd986..b6854edf01 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/NetworkListManager/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/NetworkListManager/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IEnumNetworkConnections_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn Next(&self, celt: u32, rgelt: *mut ::core::option::Option, pceltfetched: *mut u32) -> ::windows_core::Result<()>; @@ -7,9 +7,9 @@ pub trait IEnumNetworkConnections_Impl: Sized + super::super::System::Com::IDisp fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IEnumNetworkConnections {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IEnumNetworkConnections_Vtbl { pub const fn new, Impl: IEnumNetworkConnections_Impl, const OFFSET: isize>() -> IEnumNetworkConnections_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IEnumNetworkConnections_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumvar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -62,8 +62,8 @@ impl IEnumNetworkConnections_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IEnumNetworks_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn Next(&self, celt: u32, rgelt: *mut ::core::option::Option, pceltfetched: *mut u32) -> ::windows_core::Result<()>; @@ -71,9 +71,9 @@ pub trait IEnumNetworks_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IEnumNetworks {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IEnumNetworks_Vtbl { pub const fn new, Impl: IEnumNetworks_Impl, const OFFSET: isize>() -> IEnumNetworks_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IEnumNetworks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumvar: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -126,8 +126,8 @@ impl IEnumNetworks_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, sznetworknewname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -143,9 +143,9 @@ pub trait INetwork_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetCategory(&self) -> ::windows_core::Result; fn SetCategory(&self, newcategory: NLM_NETWORK_CATEGORY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetwork {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetwork_Vtbl { pub const fn new, Impl: INetwork_Impl, const OFFSET: isize>() -> INetwork_Vtbl { unsafe extern "system" fn GetName, Impl: INetwork_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psznetworkname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -288,14 +288,14 @@ impl INetwork_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetwork2_Impl: Sized + INetwork_Impl { fn IsDomainAuthenticatedBy(&self, domainauthenticationkind: NLM_DOMAIN_AUTHENTICATION_KIND) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetwork2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetwork2_Vtbl { pub const fn new, Impl: INetwork2_Impl, const OFFSET: isize>() -> INetwork2_Vtbl { unsafe extern "system" fn IsDomainAuthenticatedBy, Impl: INetwork2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, domainauthenticationkind: NLM_DOMAIN_AUTHENTICATION_KIND, pvalue: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -315,8 +315,8 @@ impl INetwork2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetworkConnection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetNetwork(&self) -> ::windows_core::Result; fn IsConnectedToInternet(&self) -> ::windows_core::Result; @@ -326,9 +326,9 @@ pub trait INetworkConnection_Impl: Sized + super::super::System::Com::IDispatch_ fn GetAdapterId(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetDomainType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetworkConnection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetworkConnection_Vtbl { pub const fn new, Impl: INetworkConnection_Impl, const OFFSET: isize>() -> INetworkConnection_Vtbl { unsafe extern "system" fn GetNetwork, Impl: INetworkConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -423,14 +423,14 @@ impl INetworkConnection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetworkConnection2_Impl: Sized + INetworkConnection_Impl { fn IsDomainAuthenticatedBy(&self, domainauthenticationkind: NLM_DOMAIN_AUTHENTICATION_KIND) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetworkConnection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetworkConnection2_Vtbl { pub const fn new, Impl: INetworkConnection2_Impl, const OFFSET: isize>() -> INetworkConnection2_Vtbl { unsafe extern "system" fn IsDomainAuthenticatedBy, Impl: INetworkConnection2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, domainauthenticationkind: NLM_DOMAIN_AUTHENTICATION_KIND, pvalue: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -639,8 +639,8 @@ impl INetworkEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetworkListManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetNetworks(&self, flags: NLM_ENUM_NETWORK) -> ::windows_core::Result; fn GetNetwork(&self, gdnetworkid: &::windows_core::GUID) -> ::windows_core::Result; @@ -652,9 +652,9 @@ pub trait INetworkListManager_Impl: Sized + super::super::System::Com::IDispatch fn SetSimulatedProfileInfo(&self, psimulatedinfo: *const NLM_SIMULATED_PROFILE_INFO) -> ::windows_core::Result<()>; fn ClearSimulatedProfileInfo(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetworkListManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetworkListManager_Vtbl { pub const fn new, Impl: INetworkListManager_Impl, const OFFSET: isize>() -> INetworkListManager_Vtbl { unsafe extern "system" fn GetNetworks, Impl: INetworkListManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: NLM_ENUM_NETWORK, ppenumnetwork: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/impl.rs b/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/impl.rs index 94b7e43f3f..0e994bf3ae 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/impl.rs @@ -1,32 +1,32 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWinHttpRequest_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn SetProxy(&self, proxysetting: i32, proxyserver: &super::super::System::Variant::VARIANT, bypasslist: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetProxy(&self, proxysetting: i32, proxyserver: &::windows_core::VARIANT, bypasslist: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetCredentials(&self, username: &::windows_core::BSTR, password: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<()>; - fn Open(&self, method: &::windows_core::BSTR, url: &::windows_core::BSTR, r#async: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Open(&self, method: &::windows_core::BSTR, url: &::windows_core::BSTR, r#async: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetRequestHeader(&self, header: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetResponseHeader(&self, header: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn GetAllResponseHeaders(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Send(&self, body: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Send(&self, body: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Status(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ResponseText(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn ResponseBody(&self) -> ::windows_core::Result; - fn ResponseStream(&self) -> ::windows_core::Result; - fn get_Option(&self, option: WinHttpRequestOption) -> ::windows_core::Result; - fn put_Option(&self, option: WinHttpRequestOption, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn WaitForResponse(&self, timeout: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn ResponseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ResponseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn get_Option(&self, option: WinHttpRequestOption) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_Option(&self, option: WinHttpRequestOption, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn WaitForResponse(&self, timeout: &::windows_core::VARIANT) -> ::windows_core::Result; fn Abort(&self) -> ::windows_core::Result<()>; fn SetTimeouts(&self, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::Result<()>; fn SetClientCertificate(&self, clientcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetAutoLogonPolicy(&self, autologonpolicy: WinHttpRequestAutoLogonPolicy) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWinHttpRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWinHttpRequest_Vtbl { pub const fn new, Impl: IWinHttpRequest_Impl, const OFFSET: isize>() -> IWinHttpRequest_Vtbl { - unsafe extern "system" fn SetProxy, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proxysetting: i32, proxyserver: super::super::System::Variant::VARIANT, bypasslist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProxy, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, proxysetting: i32, proxyserver: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bypasslist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProxy(::core::mem::transmute_copy(&proxysetting), ::core::mem::transmute(&proxyserver), ::core::mem::transmute(&bypasslist)).into() @@ -36,7 +36,7 @@ impl IWinHttpRequest_Vtbl { let this = (*this).get_impl(); this.SetCredentials(::core::mem::transmute(&username), ::core::mem::transmute(&password), ::core::mem::transmute_copy(&flags)).into() } - unsafe extern "system" fn Open, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, method: ::std::mem::MaybeUninit<::windows_core::BSTR>, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#async: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Open, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, method: ::std::mem::MaybeUninit<::windows_core::BSTR>, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#async: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Open(::core::mem::transmute(&method), ::core::mem::transmute(&url), ::core::mem::transmute(&r#async)).into() @@ -68,7 +68,7 @@ impl IWinHttpRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Send, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Send, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Send(::core::mem::transmute(&body)).into() @@ -106,7 +106,7 @@ impl IWinHttpRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ResponseBody, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ResponseBody, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ResponseBody() { @@ -117,7 +117,7 @@ impl IWinHttpRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ResponseStream, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ResponseStream, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, body: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ResponseStream() { @@ -128,7 +128,7 @@ impl IWinHttpRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Option, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Option, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Option(::core::mem::transmute_copy(&option)) { @@ -139,12 +139,12 @@ impl IWinHttpRequest_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Option, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Option, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Option(::core::mem::transmute_copy(&option), ::core::mem::transmute(&value)).into() } - unsafe extern "system" fn WaitForResponse, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, timeout: super::super::System::Variant::VARIANT, succeeded: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn WaitForResponse, Impl: IWinHttpRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, timeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, succeeded: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.WaitForResponse(::core::mem::transmute(&timeout)) { diff --git a/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/mod.rs b/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/mod.rs index 11aa678f89..db86aa2cd7 100644 --- a/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Networking/WinHttp/mod.rs @@ -333,10 +333,12 @@ where ::windows_core::imp::interface_hierarchy!(IWinHttpRequest, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IWinHttpRequest { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProxy(&self, proxysetting: i32, proxyserver: super::super::System::Variant::VARIANT, bypasslist: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProxy)(::windows_core::Interface::as_raw(self), proxysetting, ::core::mem::transmute(proxyserver), ::core::mem::transmute(bypasslist)).ok() + pub unsafe fn SetProxy(&self, proxysetting: i32, proxyserver: P0, bypasslist: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProxy)(::windows_core::Interface::as_raw(self), proxysetting, proxyserver.into_param().abi(), bypasslist.into_param().abi()).ok() } pub unsafe fn SetCredentials(&self, username: P0, password: P1, flags: i32) -> ::windows_core::Result<()> where @@ -345,14 +347,13 @@ impl IWinHttpRequest { { (::windows_core::Interface::vtable(self).SetCredentials)(::windows_core::Interface::as_raw(self), username.into_param().abi(), password.into_param().abi(), flags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, method: P0, url: P1, r#async: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Open(&self, method: P0, url: P1, r#async: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), method.into_param().abi(), url.into_param().abi(), ::core::mem::transmute(r#async)).ok() + (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), method.into_param().abi(), url.into_param().abi(), r#async.into_param().abi()).ok() } pub unsafe fn SetRequestHeader(&self, header: P0, value: P1) -> ::windows_core::Result<()> where @@ -372,10 +373,11 @@ impl IWinHttpRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllResponseHeaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Send(&self, body: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(body)).ok() + pub unsafe fn Send(&self, body: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), body.into_param().abi()).ok() } pub unsafe fn Status(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -389,34 +391,30 @@ impl IWinHttpRequest { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ResponseText)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ResponseBody(&self) -> ::windows_core::Result { + pub unsafe fn ResponseBody(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ResponseBody)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ResponseStream(&self) -> ::windows_core::Result { + pub unsafe fn ResponseStream(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ResponseStream)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Option(&self, option: WinHttpRequestOption) -> ::windows_core::Result { + pub unsafe fn get_Option(&self, option: WinHttpRequestOption) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Option)(::windows_core::Interface::as_raw(self), option, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Option(&self, option: WinHttpRequestOption, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).put_Option)(::windows_core::Interface::as_raw(self), option, ::core::mem::transmute(value)).ok() + pub unsafe fn put_Option(&self, option: WinHttpRequestOption, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).put_Option)(::windows_core::Interface::as_raw(self), option, value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn WaitForResponse(&self, timeout: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn WaitForResponse(&self, timeout: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).WaitForResponse)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(timeout), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).WaitForResponse)(::windows_core::Interface::as_raw(self), timeout.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Abort(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Abort)(::windows_core::Interface::as_raw(self)).ok() @@ -439,45 +437,21 @@ impl IWinHttpRequest { #[doc(hidden)] pub struct IWinHttpRequest_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProxy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proxysetting: i32, proxyserver: super::super::System::Variant::VARIANT, bypasslist: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProxy: usize, + pub SetProxy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, proxysetting: i32, proxyserver: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bypasslist: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetCredentials: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, method: ::std::mem::MaybeUninit<::windows_core::BSTR>, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#async: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Open: usize, + pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, method: ::std::mem::MaybeUninit<::windows_core::BSTR>, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#async: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetRequestHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, header: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetResponseHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, header: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetAllResponseHeaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, headers: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Send: usize, + pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, status: *mut i32) -> ::windows_core::HRESULT, pub StatusText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, status: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ResponseText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ResponseBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ResponseBody: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ResponseStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ResponseStream: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Option: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Option: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Option: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_Option: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub WaitForResponse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, timeout: super::super::System::Variant::VARIANT, succeeded: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - WaitForResponse: usize, + pub ResponseBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ResponseStream: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, body: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub get_Option: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_Option: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: WinHttpRequestOption, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub WaitForResponse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, timeout: ::std::mem::MaybeUninit<::windows_core::VARIANT>, succeeded: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetTimeouts: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resolvetimeout: i32, connecttimeout: i32, sendtimeout: i32, receivetimeout: i32) -> ::windows_core::HRESULT, pub SetClientCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, clientcertificate: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/impl.rs b/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/impl.rs index 98472a5598..f6a5ea7bdb 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/impl.rs @@ -63,8 +63,8 @@ impl AsyncIAssociatedIdentityProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait AsyncIConnectedIdentityProvider_Impl: Sized { fn Begin_ConnectIdentity(&self, authbuffer: *const u8, authbuffersize: u32) -> ::windows_core::Result<()>; fn Finish_ConnectIdentity(&self) -> ::windows_core::Result<()>; @@ -73,13 +73,13 @@ pub trait AsyncIConnectedIdentityProvider_Impl: Sized { fn Begin_IsConnected(&self) -> ::windows_core::Result<()>; fn Finish_IsConnected(&self) -> ::windows_core::Result; fn Begin_GetUrl(&self, identifier: IDENTITY_URL, context: ::core::option::Option<&super::super::super::super::System::Com::IBindCtx>) -> ::windows_core::Result<()>; - fn Finish_GetUrl(&self, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; + fn Finish_GetUrl(&self, postdata: *mut ::windows_core::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn Begin_GetAccountState(&self) -> ::windows_core::Result<()>; fn Finish_GetAccountState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for AsyncIConnectedIdentityProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl AsyncIConnectedIdentityProvider_Vtbl { pub const fn new, Impl: AsyncIConnectedIdentityProvider_Impl, const OFFSET: isize>() -> AsyncIConnectedIdentityProvider_Vtbl { unsafe extern "system" fn Begin_ConnectIdentity, Impl: AsyncIConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, authbuffer: *const u8, authbuffersize: u32) -> ::windows_core::HRESULT { @@ -123,7 +123,7 @@ impl AsyncIConnectedIdentityProvider_Vtbl { let this = (*this).get_impl(); this.Begin_GetUrl(::core::mem::transmute_copy(&identifier), ::windows_core::from_raw_borrowed(&context)).into() } - unsafe extern "system" fn Finish_GetUrl, Impl: AsyncIConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn Finish_GetUrl, Impl: AsyncIConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, postdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Finish_GetUrl(::core::mem::transmute_copy(&postdata), ::core::mem::transmute_copy(&url)).into() @@ -234,16 +234,16 @@ impl AsyncIIdentityAuthentication_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait AsyncIIdentityProvider_Impl: Sized { - fn Begin_GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Begin_GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Finish_GetIdentityEnum(&self) -> ::windows_core::Result; - fn Begin_Create(&self, lpszusername: &::windows_core::PCWSTR, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Begin_Create(&self, lpszusername: &::windows_core::PCWSTR, pkeywordstoadd: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Finish_Create(&self) -> ::windows_core::Result; fn Begin_Import(&self, ppropertystore: ::core::option::Option<&super::super::super::super::UI::Shell::PropertiesSystem::IPropertyStore>) -> ::windows_core::Result<()>; fn Finish_Import(&self) -> ::windows_core::Result<()>; - fn Begin_Delete(&self, lpszuniqueid: &::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Begin_Delete(&self, lpszuniqueid: &::windows_core::PCWSTR, pkeywordstodelete: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Finish_Delete(&self) -> ::windows_core::Result<()>; fn Begin_FindByUniqueID(&self, lpszuniqueid: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn Finish_FindByUniqueID(&self) -> ::windows_core::Result; @@ -254,12 +254,12 @@ pub trait AsyncIIdentityProvider_Impl: Sized { fn Begin_UnAdvise(&self, dwcookie: u32) -> ::windows_core::Result<()>; fn Finish_UnAdvise(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for AsyncIIdentityProvider {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl AsyncIIdentityProvider_Vtbl { pub const fn new, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>() -> AsyncIIdentityProvider_Vtbl { - unsafe extern "system" fn Begin_GetIdentityEnum, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Begin_GetIdentityEnum, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Begin_GetIdentityEnum(::core::mem::transmute_copy(&eidentitytype), ::core::mem::transmute_copy(&pfilterkey), ::core::mem::transmute_copy(&pfilterpropvarvalue)).into() @@ -275,7 +275,7 @@ impl AsyncIIdentityProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Begin_Create, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Begin_Create, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pkeywordstoadd: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Begin_Create(::core::mem::transmute(&lpszusername), ::core::mem::transmute_copy(&pkeywordstoadd)).into() @@ -301,7 +301,7 @@ impl AsyncIIdentityProvider_Vtbl { let this = (*this).get_impl(); this.Finish_Import().into() } - unsafe extern "system" fn Begin_Delete, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Begin_Delete, Impl: AsyncIIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Begin_Delete(::core::mem::transmute(&lpszuniqueid), ::core::mem::transmute_copy(&pkeywordstodelete)).into() @@ -393,8 +393,8 @@ impl AsyncIIdentityProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait AsyncIIdentityStore_Impl: Sized { fn Begin_GetCount(&self) -> ::windows_core::Result<()>; fn Finish_GetCount(&self) -> ::windows_core::Result; @@ -404,14 +404,14 @@ pub trait AsyncIIdentityStore_Impl: Sized { fn Finish_AddToCache(&self) -> ::windows_core::Result<()>; fn Begin_ConvertToSid(&self, lpszuniqueid: &::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID, cbsid: u16, psid: *mut u8) -> ::windows_core::Result<()>; fn Finish_ConvertToSid(&self, psid: *mut u8, pcbrequiredsid: *mut u16) -> ::windows_core::Result<()>; - fn Begin_EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Begin_EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Finish_EnumerateIdentities(&self) -> ::windows_core::Result; fn Begin_Reset(&self) -> ::windows_core::Result<()>; fn Finish_Reset(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for AsyncIIdentityStore {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl AsyncIIdentityStore_Vtbl { pub const fn new, Impl: AsyncIIdentityStore_Impl, const OFFSET: isize>() -> AsyncIIdentityStore_Vtbl { unsafe extern "system" fn Begin_GetCount, Impl: AsyncIIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -460,7 +460,7 @@ impl AsyncIIdentityStore_Vtbl { let this = (*this).get_impl(); this.Finish_ConvertToSid(::core::mem::transmute_copy(&psid), ::core::mem::transmute_copy(&pcbrequiredsid)).into() } - unsafe extern "system" fn Begin_EnumerateIdentities, Impl: AsyncIIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Begin_EnumerateIdentities, Impl: AsyncIIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Begin_EnumerateIdentities(::core::mem::transmute_copy(&eidentitytype), ::core::mem::transmute_copy(&pfilterkey), ::core::mem::transmute_copy(&pfilterpropvarvalue)).into() @@ -591,18 +591,18 @@ impl IAssociatedIdentityProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IConnectedIdentityProvider_Impl: Sized { fn ConnectIdentity(&self, authbuffer: *const u8, authbuffersize: u32) -> ::windows_core::Result<()>; fn DisconnectIdentity(&self) -> ::windows_core::Result<()>; fn IsConnected(&self) -> ::windows_core::Result; - fn GetUrl(&self, identifier: IDENTITY_URL, context: ::core::option::Option<&super::super::super::super::System::Com::IBindCtx>, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; + fn GetUrl(&self, identifier: IDENTITY_URL, context: ::core::option::Option<&super::super::super::super::System::Com::IBindCtx>, postdata: *mut ::windows_core::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn GetAccountState(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IConnectedIdentityProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IConnectedIdentityProvider_Vtbl { pub const fn new, Impl: IConnectedIdentityProvider_Impl, const OFFSET: isize>() -> IConnectedIdentityProvider_Vtbl { unsafe extern "system" fn ConnectIdentity, Impl: IConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, authbuffer: *const u8, authbuffersize: u32) -> ::windows_core::HRESULT { @@ -626,7 +626,7 @@ impl IConnectedIdentityProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetUrl, Impl: IConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: IDENTITY_URL, context: *mut ::core::ffi::c_void, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetUrl, Impl: IConnectedIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: IDENTITY_URL, context: *mut ::core::ffi::c_void, postdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetUrl(::core::mem::transmute_copy(&identifier), ::windows_core::from_raw_borrowed(&context), ::core::mem::transmute_copy(&postdata), ::core::mem::transmute_copy(&url)).into() @@ -703,24 +703,24 @@ impl IIdentityAuthentication_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IIdentityProvider_Impl: Sized { - fn GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; - fn Create(&self, lpszusername: &::windows_core::PCWSTR, pppropertystore: *mut ::core::option::Option, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result; + fn Create(&self, lpszusername: &::windows_core::PCWSTR, pppropertystore: *mut ::core::option::Option, pkeywordstoadd: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Import(&self, ppropertystore: ::core::option::Option<&super::super::super::super::UI::Shell::PropertiesSystem::IPropertyStore>) -> ::windows_core::Result<()>; - fn Delete(&self, lpszuniqueid: &::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Delete(&self, lpszuniqueid: &::windows_core::PCWSTR, pkeywordstodelete: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn FindByUniqueID(&self, lpszuniqueid: &::windows_core::PCWSTR) -> ::windows_core::Result; fn GetProviderPropertyStore(&self) -> ::windows_core::Result; fn Advise(&self, pidentityadvise: ::core::option::Option<&IIdentityAdvise>, dwidentityupdateevents: &IdentityUpdateEvent) -> ::windows_core::Result; fn UnAdvise(&self, dwcookie: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IIdentityProvider {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IIdentityProvider_Vtbl { pub const fn new, Impl: IIdentityProvider_Impl, const OFFSET: isize>() -> IIdentityProvider_Vtbl { - unsafe extern "system" fn GetIdentityEnum, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetIdentityEnum, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetIdentityEnum(::core::mem::transmute_copy(&eidentitytype), ::core::mem::transmute_copy(&pfilterkey), ::core::mem::transmute_copy(&pfilterpropvarvalue)) { @@ -731,7 +731,7 @@ impl IIdentityProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pppropertystore: *mut *mut ::core::ffi::c_void, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pppropertystore: *mut *mut ::core::ffi::c_void, pkeywordstoadd: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Create(::core::mem::transmute(&lpszusername), ::core::mem::transmute_copy(&pppropertystore), ::core::mem::transmute_copy(&pkeywordstoadd)).into() @@ -741,7 +741,7 @@ impl IIdentityProvider_Vtbl { let this = (*this).get_impl(); this.Import(::windows_core::from_raw_borrowed(&ppropertystore)).into() } - unsafe extern "system" fn Delete, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Delete, Impl: IIdentityProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Delete(::core::mem::transmute(&lpszuniqueid), ::core::mem::transmute_copy(&pkeywordstodelete)).into() @@ -800,19 +800,19 @@ impl IIdentityProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IIdentityStore_Impl: Sized { fn GetCount(&self) -> ::windows_core::Result; fn GetAt(&self, dwprovider: u32, pprovguid: *mut ::windows_core::GUID, ppidentityprovider: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn AddToCache(&self, lpszuniqueid: &::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn ConvertToSid(&self, lpszuniqueid: &::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID, cbsid: u16, psid: *mut u8, pcbrequiredsid: *mut u16) -> ::windows_core::Result<()>; - fn EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; + fn EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result; fn Reset(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IIdentityStore {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IIdentityStore_Vtbl { pub const fn new, Impl: IIdentityStore_Impl, const OFFSET: isize>() -> IIdentityStore_Vtbl { unsafe extern "system" fn GetCount, Impl: IIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwproviders: *mut u32) -> ::windows_core::HRESULT { @@ -841,7 +841,7 @@ impl IIdentityStore_Vtbl { let this = (*this).get_impl(); this.ConvertToSid(::core::mem::transmute(&lpszuniqueid), ::core::mem::transmute_copy(&providerguid), ::core::mem::transmute_copy(&cbsid), ::core::mem::transmute_copy(&psid), ::core::mem::transmute_copy(&pcbrequiredsid)).into() } - unsafe extern "system" fn EnumerateIdentities, Impl: IIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnumerateIdentities, Impl: IIdentityStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EnumerateIdentities(::core::mem::transmute_copy(&eidentitytype), ::core::mem::transmute_copy(&pfilterkey), ::core::mem::transmute_copy(&pfilterpropvarvalue)) { diff --git a/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/mod.rs b/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/mod.rs index 1e45b338bc..60c637999e 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Authentication/Identity/Provider/mod.rs @@ -78,10 +78,8 @@ impl AsyncIConnectedIdentityProvider { { (::windows_core::Interface::vtable(self).Begin_GetUrl)(::windows_core::Interface::as_raw(self), identifier, context.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Finish_GetUrl(&self, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Finish_GetUrl)(::windows_core::Interface::as_raw(self), postdata, url).ok() + pub unsafe fn Finish_GetUrl(&self, postdata: *mut ::windows_core::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Finish_GetUrl)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(postdata), url).ok() } pub unsafe fn Begin_GetAccountState(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Begin_GetAccountState)(::windows_core::Interface::as_raw(self)).ok() @@ -105,10 +103,7 @@ pub struct AsyncIConnectedIdentityProvider_Vtbl { pub Begin_GetUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: IDENTITY_URL, context: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Begin_GetUrl: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Finish_GetUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Finish_GetUrl: usize, + pub Finish_GetUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, postdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub Begin_GetAccountState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Finish_GetAccountState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstate: *mut ACCOUNT_STATE) -> ::windows_core::HRESULT, } @@ -170,9 +165,9 @@ pub struct AsyncIIdentityAuthentication_Vtbl { ::windows_core::imp::com_interface!(AsyncIIdentityProvider, AsyncIIdentityProvider_Vtbl, 0xc6fc9901_c433_4646_8f48_4e4687aae2a0); ::windows_core::imp::interface_hierarchy!(AsyncIIdentityProvider, ::windows_core::IUnknown); impl AsyncIIdentityProvider { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Begin_GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Begin_GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Begin_GetIdentityEnum)(::windows_core::Interface::as_raw(self), eidentitytype, ::core::mem::transmute(pfilterkey.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pfilterpropvarvalue.unwrap_or(::std::ptr::null()))).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] @@ -181,13 +176,11 @@ impl AsyncIIdentityProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Finish_GetIdentityEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Begin_Create(&self, lpszusername: P0, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Begin_Create(&self, lpszusername: P0, pkeywordstoadd: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Begin_Create)(::windows_core::Interface::as_raw(self), lpszusername.into_param().abi(), pkeywordstoadd).ok() + (::windows_core::Interface::vtable(self).Begin_Create)(::windows_core::Interface::as_raw(self), lpszusername.into_param().abi(), ::core::mem::transmute(pkeywordstoadd)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -206,13 +199,11 @@ impl AsyncIIdentityProvider { pub unsafe fn Finish_Import(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Finish_Import)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Begin_Delete(&self, lpszuniqueid: P0, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Begin_Delete(&self, lpszuniqueid: P0, pkeywordstodelete: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Begin_Delete)(::windows_core::Interface::as_raw(self), lpszuniqueid.into_param().abi(), pkeywordstodelete).ok() + (::windows_core::Interface::vtable(self).Begin_Delete)(::windows_core::Interface::as_raw(self), lpszuniqueid.into_param().abi(), ::core::mem::transmute(pkeywordstodelete)).ok() } pub unsafe fn Finish_Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Finish_Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -259,18 +250,15 @@ impl AsyncIIdentityProvider { #[doc(hidden)] pub struct AsyncIIdentityProvider_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Begin_GetIdentityEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Begin_GetIdentityEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Begin_GetIdentityEnum: usize, #[cfg(feature = "Win32_System_Com")] pub Finish_GetIdentityEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Finish_GetIdentityEnum: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Begin_Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Begin_Create: usize, + pub Begin_Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pkeywordstoadd: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub Finish_Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pppropertystore: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] @@ -280,10 +268,7 @@ pub struct AsyncIIdentityProvider_Vtbl { #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Begin_Import: usize, pub Finish_Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Begin_Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Begin_Delete: usize, + pub Begin_Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Finish_Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Begin_FindByUniqueID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -334,9 +319,9 @@ impl AsyncIIdentityStore { pub unsafe fn Finish_ConvertToSid(&self, psid: ::core::option::Option<*mut u8>, pcbrequiredsid: *mut u16) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Finish_ConvertToSid)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(psid.unwrap_or(::std::ptr::null_mut())), pcbrequiredsid).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Begin_EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Begin_EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Begin_EnumerateIdentities)(::windows_core::Interface::as_raw(self), eidentitytype, ::core::mem::transmute(pfilterkey.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pfilterpropvarvalue.unwrap_or(::std::ptr::null()))).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] @@ -364,9 +349,9 @@ pub struct AsyncIIdentityStore_Vtbl { pub Finish_AddToCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Begin_ConvertToSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID, cbsid: u16, psid: *mut u8) -> ::windows_core::HRESULT, pub Finish_ConvertToSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psid: *mut u8, pcbrequiredsid: *mut u16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Begin_EnumerateIdentities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Begin_EnumerateIdentities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Begin_EnumerateIdentities: usize, #[cfg(feature = "Win32_System_Com")] pub Finish_EnumerateIdentities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -458,13 +443,13 @@ impl IConnectedIdentityProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsConnected)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetUrl(&self, identifier: IDENTITY_URL, context: P0, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetUrl(&self, identifier: IDENTITY_URL, context: P0, postdata: *mut ::windows_core::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).GetUrl)(::windows_core::Interface::as_raw(self), identifier, context.into_param().abi(), postdata, url).ok() + (::windows_core::Interface::vtable(self).GetUrl)(::windows_core::Interface::as_raw(self), identifier, context.into_param().abi(), ::core::mem::transmute(postdata), url).ok() } pub unsafe fn GetAccountState(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -478,9 +463,9 @@ pub struct IConnectedIdentityProvider_Vtbl { pub ConnectIdentity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, authbuffer: *const u8, authbuffersize: u32) -> ::windows_core::HRESULT, pub DisconnectIdentity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub IsConnected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, connected: *mut super::super::super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: IDENTITY_URL, context: *mut ::core::ffi::c_void, postdata: *mut super::super::super::super::System::Variant::VARIANT, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GetUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: IDENTITY_URL, context: *mut ::core::ffi::c_void, postdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, url: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetUrl: usize, pub GetAccountState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstate: *mut ACCOUNT_STATE) -> ::windows_core::HRESULT, } @@ -525,19 +510,19 @@ pub struct IIdentityAuthentication_Vtbl { ::windows_core::imp::com_interface!(IIdentityProvider, IIdentityProvider_Vtbl, 0x0d1b9e0c_e8ba_4f55_a81b_bce934b948f5); ::windows_core::imp::interface_hierarchy!(IIdentityProvider, ::windows_core::IUnknown); impl IIdentityProvider { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn GetIdentityEnum(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetIdentityEnum)(::windows_core::Interface::as_raw(self), eidentitytype, ::core::mem::transmute(pfilterkey.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pfilterpropvarvalue.unwrap_or(::std::ptr::null())), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Create(&self, lpszusername: P0, pppropertystore: *mut ::core::option::Option, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Create(&self, lpszusername: P0, pppropertystore: *mut ::core::option::Option, pkeywordstoadd: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), lpszusername.into_param().abi(), ::core::mem::transmute(pppropertystore), pkeywordstoadd).ok() + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), lpszusername.into_param().abi(), ::core::mem::transmute(pppropertystore), ::core::mem::transmute(pkeywordstoadd)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -547,13 +532,11 @@ impl IIdentityProvider { { (::windows_core::Interface::vtable(self).Import)(::windows_core::Interface::as_raw(self), ppropertystore.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Delete(&self, lpszuniqueid: P0, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn Delete(&self, lpszuniqueid: P0, pkeywordstodelete: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), lpszuniqueid.into_param().abi(), pkeywordstodelete).ok() + (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), lpszuniqueid.into_param().abi(), ::core::mem::transmute(pkeywordstodelete)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -585,22 +568,19 @@ impl IIdentityProvider { #[doc(hidden)] pub struct IIdentityProvider_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetIdentityEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub GetIdentityEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem")))] GetIdentityEnum: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pppropertystore: *mut *mut ::core::ffi::c_void, pkeywordstoadd: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszusername: ::windows_core::PCWSTR, pppropertystore: *mut *mut ::core::ffi::c_void, pkeywordstoadd: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Create: usize, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropertystore: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Import: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Delete: usize, + pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pkeywordstodelete: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub FindByUniqueID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, pppropertystore: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] @@ -634,9 +614,9 @@ impl IIdentityStore { { (::windows_core::Interface::vtable(self).ConvertToSid)(::windows_core::Interface::as_raw(self), lpszuniqueid.into_param().abi(), providerguid, psid.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(psid.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcbrequiredsid).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn EnumerateIdentities(&self, eidentitytype: IDENTITY_TYPE, pfilterkey: ::core::option::Option<*const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pfilterpropvarvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumerateIdentities)(::windows_core::Interface::as_raw(self), eidentitytype, ::core::mem::transmute(pfilterkey.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pfilterpropvarvalue.unwrap_or(::std::ptr::null())), &mut result__).from_abi(result__) } @@ -652,9 +632,9 @@ pub struct IIdentityStore_Vtbl { pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwprovider: u32, pprovguid: *mut ::windows_core::GUID, ppidentityprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub AddToCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID) -> ::windows_core::HRESULT, pub ConvertToSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpszuniqueid: ::windows_core::PCWSTR, providerguid: *const ::windows_core::GUID, cbsid: u16, psid: *mut u8, pcbrequiredsid: *mut u16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub EnumerateIdentities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const super::super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub EnumerateIdentities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eidentitytype: IDENTITY_TYPE, pfilterkey: *const super::super::super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pfilterpropvarvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppidentityenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem")))] EnumerateIdentities: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/Security/Authorization/impl.rs b/crates/libs/windows/src/Windows/Win32/Security/Authorization/impl.rs index b0d4cba835..eea94e6144 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Authorization/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Authorization/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplication_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -16,56 +16,56 @@ pub trait IAzApplication_Impl: Sized + super::super::System::Com::IDispatch_Impl fn ApplyStoreSacl(&self) -> ::windows_core::Result; fn SetApplyStoreSacl(&self, bprop: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PolicyAdministrators(&self) -> ::windows_core::Result; - fn PolicyReaders(&self) -> ::windows_core::Result; - fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Scopes(&self) -> ::windows_core::Result; - fn OpenScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteScope(&self, bstrscopename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Operations(&self) -> ::windows_core::Result; - fn OpenOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteOperation(&self, bstroperationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Tasks(&self) -> ::windows_core::Result; - fn OpenTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ApplicationGroups(&self) -> ::windows_core::Result; - fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Roles(&self) -> ::windows_core::Result; - fn OpenRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn AddPropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn InitializeClientContextFromName(&self, clientname: &::windows_core::BSTR, domainname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DelegatedPolicyUsers(&self) -> ::windows_core::Result; - fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn InitializeClientContextFromStringSid(&self, sidstring: &::windows_core::BSTR, loptions: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn PolicyAdministratorsName(&self) -> ::windows_core::Result; - fn PolicyReadersName(&self) -> ::windows_core::Result; - fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result; - fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn AddPropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn InitializeClientContextFromName(&self, clientname: &::windows_core::BSTR, domainname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn InitializeClientContextFromStringSid(&self, sidstring: &::windows_core::BSTR, loptions: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplication_Vtbl { pub const fn new, Impl: IAzApplication_Impl, const OFFSET: isize>() -> IAzApplication_Vtbl { unsafe extern "system" fn Name, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -191,7 +191,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -202,12 +202,12 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn PolicyAdministrators, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministrators, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministrators() { @@ -218,7 +218,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReaders, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReaders, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReaders() { @@ -229,22 +229,22 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReader, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReader, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReader, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReader, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() @@ -260,7 +260,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenScope(::core::mem::transmute(&bstrscopename), ::core::mem::transmute(&varreserved)) { @@ -271,7 +271,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateScope(::core::mem::transmute(&bstrscopename), ::core::mem::transmute(&varreserved)) { @@ -282,7 +282,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteScope, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteScope(::core::mem::transmute(&bstrscopename), ::core::mem::transmute(&varreserved)).into() @@ -298,7 +298,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenOperation(::core::mem::transmute(&bstroperationname), ::core::mem::transmute(&varreserved)) { @@ -309,7 +309,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateOperation(::core::mem::transmute(&bstroperationname), ::core::mem::transmute(&varreserved)) { @@ -320,7 +320,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteOperation, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteOperation(::core::mem::transmute(&bstroperationname), ::core::mem::transmute(&varreserved)).into() @@ -336,7 +336,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)) { @@ -347,7 +347,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)) { @@ -358,7 +358,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteTask, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)).into() @@ -374,7 +374,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -385,7 +385,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -396,7 +396,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)).into() @@ -412,7 +412,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)) { @@ -423,7 +423,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)) { @@ -434,12 +434,12 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteRole, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn InitializeClientContextFromToken, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ulltokenhandle: u64, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeClientContextFromToken, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ulltokenhandle: u64, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.InitializeClientContextFromToken(::core::mem::transmute_copy(&ulltokenhandle), ::core::mem::transmute(&varreserved)) { @@ -450,22 +450,22 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPropertyItem, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn InitializeClientContextFromName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, clientname: ::std::mem::MaybeUninit<::windows_core::BSTR>, domainname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeClientContextFromName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, clientname: ::std::mem::MaybeUninit<::windows_core::BSTR>, domainname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.InitializeClientContextFromName(::core::mem::transmute(&clientname), ::core::mem::transmute(&domainname), ::core::mem::transmute(&varreserved)) { @@ -476,7 +476,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DelegatedPolicyUsers, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DelegatedPolicyUsers, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DelegatedPolicyUsers() { @@ -487,17 +487,17 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddDelegatedPolicyUser, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddDelegatedPolicyUser, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddDelegatedPolicyUser(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteDelegatedPolicyUser, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteDelegatedPolicyUser, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteDelegatedPolicyUser(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn InitializeClientContextFromStringSid, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sidstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: i32, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeClientContextFromStringSid, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sidstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.InitializeClientContextFromStringSid(::core::mem::transmute(&sidstring), ::core::mem::transmute_copy(&loptions), ::core::mem::transmute(&varreserved)) { @@ -508,7 +508,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministratorsName() { @@ -519,7 +519,7 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReadersName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReadersName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReadersName() { @@ -530,27 +530,27 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReaderName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReaderName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DelegatedPolicyUsersName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DelegatedPolicyUsersName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DelegatedPolicyUsersName() { @@ -561,12 +561,12 @@ impl IAzApplication_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddDelegatedPolicyUserName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddDelegatedPolicyUserName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddDelegatedPolicyUserName(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteDelegatedPolicyUserName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteDelegatedPolicyUserName, Impl: IAzApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteDelegatedPolicyUserName(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() @@ -640,18 +640,18 @@ impl IAzApplication_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplication2_Impl: Sized + IAzApplication_Impl { - fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn InitializeClientContext2(&self, identifyingstring: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn InitializeClientContext2(&self, identifyingstring: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplication2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplication2_Vtbl { pub const fn new, Impl: IAzApplication2_Impl, const OFFSET: isize>() -> IAzApplication2_Vtbl { - unsafe extern "system" fn InitializeClientContextFromToken2, Impl: IAzApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeClientContextFromToken2, Impl: IAzApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.InitializeClientContextFromToken2(::core::mem::transmute_copy(&ultokenhandlelowpart), ::core::mem::transmute_copy(&ultokenhandlehighpart), ::core::mem::transmute(&varreserved)) { @@ -662,7 +662,7 @@ impl IAzApplication2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn InitializeClientContext2, Impl: IAzApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifyingstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeClientContext2, Impl: IAzApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifyingstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.InitializeClientContext2(::core::mem::transmute(&identifyingstring), ::core::mem::transmute(&varreserved)) { @@ -683,8 +683,8 @@ impl IAzApplication2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplication3_Impl: Sized + IAzApplication2_Impl { fn ScopeExists(&self, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result; fn OpenScope2(&self, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result; @@ -701,9 +701,9 @@ pub trait IAzApplication3_Impl: Sized + IAzApplication2_Impl { fn BizRulesEnabled(&self) -> ::windows_core::Result; fn SetBizRulesEnabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplication3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplication3_Vtbl { pub const fn new, Impl: IAzApplication3_Impl, const OFFSET: isize>() -> IAzApplication3_Vtbl { unsafe extern "system" fn ScopeExists, Impl: IAzApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbexist: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -858,8 +858,8 @@ impl IAzApplication3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplicationGroup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -867,36 +867,36 @@ pub trait IAzApplicationGroup_Impl: Sized + super::super::System::Com::IDispatch fn SetType(&self, lprop: i32) -> ::windows_core::Result<()>; fn LdapQuery(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetLdapQuery(&self, bstrprop: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AppMembers(&self) -> ::windows_core::Result; - fn AppNonMembers(&self) -> ::windows_core::Result; - fn Members(&self) -> ::windows_core::Result; - fn NonMembers(&self) -> ::windows_core::Result; + fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AppNonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn NonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddAppNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteAppNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddAppNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteAppNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteNonMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddNonMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteNonMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn MembersName(&self) -> ::windows_core::Result; - fn NonMembersName(&self) -> ::windows_core::Result; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddNonMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteNonMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn NonMembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplicationGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplicationGroup_Vtbl { pub const fn new, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>() -> IAzApplicationGroup_Vtbl { unsafe extern "system" fn Name, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -947,7 +947,7 @@ impl IAzApplicationGroup_Vtbl { let this = (*this).get_impl(); this.SetLdapQuery(::core::mem::transmute(&bstrprop)).into() } - unsafe extern "system" fn AppMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AppMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AppMembers() { @@ -958,7 +958,7 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AppNonMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AppNonMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AppNonMembers() { @@ -969,7 +969,7 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Members, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Members, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Members() { @@ -980,7 +980,7 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NonMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NonMembers, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NonMembers() { @@ -1007,42 +1007,42 @@ impl IAzApplicationGroup_Vtbl { let this = (*this).get_impl(); this.SetDescription(::core::mem::transmute(&bstrdescription)).into() } - unsafe extern "system" fn AddAppMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddAppMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddAppMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteAppMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteAppMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteAppMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddAppNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddAppNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddAppNonMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteAppNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteAppNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteAppNonMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddNonMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteNonMember, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteNonMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() @@ -1058,7 +1058,7 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -1069,47 +1069,47 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPropertyItem, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddNonMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddNonMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddNonMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteNonMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteNonMemberName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteNonMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn MembersName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn MembersName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MembersName() { @@ -1120,7 +1120,7 @@ impl IAzApplicationGroup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NonMembersName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NonMembersName, Impl: IAzApplicationGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NonMembersName() { @@ -1171,8 +1171,8 @@ impl IAzApplicationGroup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplicationGroup2_Impl: Sized + IAzApplicationGroup_Impl { fn BizRule(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetBizRule(&self, bstrprop: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1182,9 +1182,9 @@ pub trait IAzApplicationGroup2_Impl: Sized + IAzApplicationGroup_Impl { fn SetBizRuleImportedPath(&self, bstrprop: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RoleAssignments(&self, bstrscopename: &::windows_core::BSTR, brecursive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplicationGroup2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplicationGroup2_Vtbl { pub const fn new, Impl: IAzApplicationGroup2_Impl, const OFFSET: isize>() -> IAzApplicationGroup2_Vtbl { unsafe extern "system" fn BizRule, Impl: IAzApplicationGroup2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1261,19 +1261,19 @@ impl IAzApplicationGroup2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplicationGroups_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplicationGroups {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplicationGroups_Vtbl { pub const fn new, Impl: IAzApplicationGroups_Impl, const OFFSET: isize>() -> IAzApplicationGroups_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzApplicationGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzApplicationGroups_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -1317,19 +1317,19 @@ impl IAzApplicationGroups_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzApplications_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzApplications {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzApplications_Vtbl { pub const fn new, Impl: IAzApplications_Impl, const OFFSET: isize>() -> IAzApplications_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzApplications_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzApplications_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -1373,8 +1373,8 @@ impl IAzApplications_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzAuthorizationStore_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1389,48 +1389,48 @@ pub trait IAzAuthorizationStore_Impl: Sized + super::super::System::Com::IDispat fn GenerateAudits(&self) -> ::windows_core::Result; fn SetGenerateAudits(&self, bprop: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PolicyAdministrators(&self) -> ::windows_core::Result; - fn PolicyReaders(&self) -> ::windows_core::Result; - fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn UpdateCache(&self, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Delete(&self, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn UpdateCache(&self, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Delete(&self, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Applications(&self) -> ::windows_core::Result; - fn OpenApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteApplication(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ApplicationGroups(&self) -> ::windows_core::Result; - fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DelegatedPolicyUsers(&self) -> ::windows_core::Result; - fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn TargetMachine(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ApplyStoreSacl(&self) -> ::windows_core::Result; fn SetApplyStoreSacl(&self, bapplystoresacl: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn PolicyAdministratorsName(&self) -> ::windows_core::Result; - fn PolicyReadersName(&self) -> ::windows_core::Result; - fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result; - fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn CloseApplication(&self, bstrapplicationname: &::windows_core::BSTR, lflag: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzAuthorizationStore {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzAuthorizationStore_Vtbl { pub const fn new, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>() -> IAzAuthorizationStore_Vtbl { unsafe extern "system" fn Description, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1540,7 +1540,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -1551,22 +1551,22 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPropertyItem, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: AZ_PROP_CONSTANTS, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: AZ_PROP_CONSTANTS, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn PolicyAdministrators, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministrators, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministrators() { @@ -1577,7 +1577,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReaders, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReaders, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReaders() { @@ -1588,37 +1588,37 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReader, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReader, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReader, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReader, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Initialize, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Initialize, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Initialize(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&bstrpolicyurl), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn UpdateCache, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UpdateCache, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.UpdateCache(::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Delete, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Delete, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Delete(::core::mem::transmute(&varreserved)).into() @@ -1634,7 +1634,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenApplication(::core::mem::transmute(&bstrapplicationname), ::core::mem::transmute(&varreserved)) { @@ -1645,7 +1645,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateApplication(::core::mem::transmute(&bstrapplicationname), ::core::mem::transmute(&varreserved)) { @@ -1656,7 +1656,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteApplication, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteApplication(::core::mem::transmute(&bstrapplicationname), ::core::mem::transmute(&varreserved)).into() @@ -1672,7 +1672,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -1683,7 +1683,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -1694,17 +1694,17 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DelegatedPolicyUsers, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DelegatedPolicyUsers, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DelegatedPolicyUsers() { @@ -1715,12 +1715,12 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddDelegatedPolicyUser, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddDelegatedPolicyUser, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddDelegatedPolicyUser(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteDelegatedPolicyUser, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteDelegatedPolicyUser, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteDelegatedPolicyUser(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() @@ -1752,7 +1752,7 @@ impl IAzAuthorizationStore_Vtbl { let this = (*this).get_impl(); this.SetApplyStoreSacl(::core::mem::transmute_copy(&bapplystoresacl)).into() } - unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministratorsName() { @@ -1763,7 +1763,7 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReadersName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReadersName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReadersName() { @@ -1774,27 +1774,27 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReaderName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReaderName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DelegatedPolicyUsersName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DelegatedPolicyUsersName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DelegatedPolicyUsersName() { @@ -1805,12 +1805,12 @@ impl IAzAuthorizationStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddDelegatedPolicyUserName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddDelegatedPolicyUserName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddDelegatedPolicyUserName(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteDelegatedPolicyUserName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteDelegatedPolicyUserName, Impl: IAzAuthorizationStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteDelegatedPolicyUserName(::core::mem::transmute(&bstrdelegatedpolicyuser), ::core::mem::transmute(&varreserved)).into() @@ -1879,18 +1879,18 @@ impl IAzAuthorizationStore_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzAuthorizationStore2_Impl: Sized + IAzAuthorizationStore_Impl { - fn OpenApplication2(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateApplication2(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn OpenApplication2(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateApplication2(&self, bstrapplicationname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzAuthorizationStore2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzAuthorizationStore2_Vtbl { pub const fn new, Impl: IAzAuthorizationStore2_Impl, const OFFSET: isize>() -> IAzAuthorizationStore2_Vtbl { - unsafe extern "system" fn OpenApplication2, Impl: IAzAuthorizationStore2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenApplication2, Impl: IAzAuthorizationStore2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenApplication2(::core::mem::transmute(&bstrapplicationname), ::core::mem::transmute(&varreserved)) { @@ -1901,7 +1901,7 @@ impl IAzAuthorizationStore2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateApplication2, Impl: IAzAuthorizationStore2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateApplication2, Impl: IAzAuthorizationStore2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateApplication2(::core::mem::transmute(&bstrapplicationname), ::core::mem::transmute(&varreserved)) { @@ -1922,8 +1922,8 @@ impl IAzAuthorizationStore2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzAuthorizationStore3_Impl: Sized + IAzAuthorizationStore2_Impl { fn IsUpdateNeeded(&self) -> ::windows_core::Result; fn BizruleGroupSupported(&self) -> ::windows_core::Result; @@ -1931,9 +1931,9 @@ pub trait IAzAuthorizationStore3_Impl: Sized + IAzAuthorizationStore2_Impl { fn IsFunctionalLevelUpgradeSupported(&self, lfunctionallevel: i32) -> ::windows_core::Result; fn GetSchemaVersion(&self, plmajorversion: *mut i32, plminorversion: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzAuthorizationStore3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzAuthorizationStore3_Vtbl { pub const fn new, Impl: IAzAuthorizationStore3_Impl, const OFFSET: isize>() -> IAzAuthorizationStore3_Vtbl { unsafe extern "system" fn IsUpdateNeeded, Impl: IAzAuthorizationStore3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbisupdateneeded: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1992,17 +1992,17 @@ impl IAzAuthorizationStore3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzBizRuleContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetBusinessRuleResult(&self, bresult: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SetBusinessRuleString(&self, bstrbusinessrulestring: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn BusinessRuleString(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetParameter(&self, bstrparametername: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetParameter(&self, bstrparametername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzBizRuleContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzBizRuleContext_Vtbl { pub const fn new, Impl: IAzBizRuleContext_Impl, const OFFSET: isize>() -> IAzBizRuleContext_Vtbl { unsafe extern "system" fn SetBusinessRuleResult, Impl: IAzBizRuleContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bresult: super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -2026,7 +2026,7 @@ impl IAzBizRuleContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetParameter, Impl: IAzBizRuleContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameter, Impl: IAzBizRuleContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParameter(::core::mem::transmute(&bstrparametername)) { @@ -2049,32 +2049,32 @@ impl IAzBizRuleContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzBizRuleInterfaces_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn AddInterface(&self, bstrinterfacename: &::windows_core::BSTR, linterfaceflag: i32, varinterface: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddInterfaces(&self, varinterfacenames: &super::super::System::Variant::VARIANT, varinterfaceflags: &super::super::System::Variant::VARIANT, varinterfaces: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetInterfaceValue(&self, bstrinterfacename: &::windows_core::BSTR, linterfaceflag: *mut i32, varinterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddInterface(&self, bstrinterfacename: &::windows_core::BSTR, linterfaceflag: i32, varinterface: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddInterfaces(&self, varinterfacenames: &::windows_core::VARIANT, varinterfaceflags: &::windows_core::VARIANT, varinterfaces: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetInterfaceValue(&self, bstrinterfacename: &::windows_core::BSTR, linterfaceflag: *mut i32, varinterface: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Remove(&self, bstrinterfacename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RemoveAll(&self) -> ::windows_core::Result<()>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzBizRuleInterfaces {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzBizRuleInterfaces_Vtbl { pub const fn new, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>() -> IAzBizRuleInterfaces_Vtbl { - unsafe extern "system" fn AddInterface, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: i32, varinterface: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddInterface, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: i32, varinterface: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddInterface(::core::mem::transmute(&bstrinterfacename), ::core::mem::transmute_copy(&linterfaceflag), ::core::mem::transmute(&varinterface)).into() } - unsafe extern "system" fn AddInterfaces, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddInterfaces, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinterfacenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaceflags: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddInterfaces(::core::mem::transmute(&varinterfacenames), ::core::mem::transmute(&varinterfaceflags), ::core::mem::transmute(&varinterfaces)).into() } - unsafe extern "system" fn GetInterfaceValue, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: *mut i32, varinterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetInterfaceValue, Impl: IAzBizRuleInterfaces_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: *mut i32, varinterface: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetInterfaceValue(::core::mem::transmute(&bstrinterfacename), ::core::mem::transmute_copy(&linterfaceflag), ::core::mem::transmute_copy(&varinterface)).into() @@ -2114,32 +2114,32 @@ impl IAzBizRuleInterfaces_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzBizRuleParameters_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn AddParameter(&self, bstrparametername: &::windows_core::BSTR, varparametervalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddParameters(&self, varparameternames: &super::super::System::Variant::VARIANT, varparametervalues: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetParameterValue(&self, bstrparametername: &::windows_core::BSTR) -> ::windows_core::Result; + fn AddParameter(&self, bstrparametername: &::windows_core::BSTR, varparametervalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddParameters(&self, varparameternames: &::windows_core::VARIANT, varparametervalues: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetParameterValue(&self, bstrparametername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn Remove(&self, varparametername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RemoveAll(&self) -> ::windows_core::Result<()>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzBizRuleParameters {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzBizRuleParameters_Vtbl { pub const fn new, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>() -> IAzBizRuleParameters_Vtbl { - unsafe extern "system" fn AddParameter, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, varparametervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddParameter, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, varparametervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddParameter(::core::mem::transmute(&bstrparametername), ::core::mem::transmute(&varparametervalue)).into() } - unsafe extern "system" fn AddParameters, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddParameters, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varparameternames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varparametervalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddParameters(::core::mem::transmute(&varparameternames), ::core::mem::transmute(&varparametervalues)).into() } - unsafe extern "system" fn GetParameterValue, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameterValue, Impl: IAzBizRuleParameters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParameterValue(::core::mem::transmute(&bstrparametername)) { @@ -2185,10 +2185,10 @@ impl IAzBizRuleParameters_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzClientContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn AccessCheck(&self, bstrobjectname: &::windows_core::BSTR, varscopenames: &super::super::System::Variant::VARIANT, varoperations: &super::super::System::Variant::VARIANT, varparameternames: &super::super::System::Variant::VARIANT, varparametervalues: &super::super::System::Variant::VARIANT, varinterfacenames: &super::super::System::Variant::VARIANT, varinterfaceflags: &super::super::System::Variant::VARIANT, varinterfaces: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn AccessCheck(&self, bstrobjectname: &::windows_core::BSTR, varscopenames: &::windows_core::VARIANT, varoperations: &::windows_core::VARIANT, varparameternames: &::windows_core::VARIANT, varparametervalues: &::windows_core::VARIANT, varinterfacenames: &::windows_core::VARIANT, varinterfaceflags: &::windows_core::VARIANT, varinterfaces: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetBusinessRuleString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserDn(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserSamCompat(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2197,17 +2197,28 @@ pub trait IAzClientContext_Impl: Sized + super::super::System::Com::IDispatch_Im fn UserCanonical(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserUpn(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserDnsSamCompat(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn GetRoles(&self, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetRoles(&self, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn RoleForAccessCheck(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetRoleForAccessCheck(&self, bstrprop: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzClientContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzClientContext_Vtbl { pub const fn new, Impl: IAzClientContext_Impl, const OFFSET: isize>() -> IAzClientContext_Vtbl { - unsafe extern "system" fn AccessCheck, Impl: IAzClientContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrobjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varscopenames: super::super::System::Variant::VARIANT, varoperations: super::super::System::Variant::VARIANT, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT, pvarresults: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AccessCheck, Impl: IAzClientContext_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + bstrobjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, + varscopenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varoperations: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varparameternames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varparametervalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varinterfacenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varinterfaceflags: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + varinterfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>, + pvarresults: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AccessCheck(::core::mem::transmute(&bstrobjectname), ::core::mem::transmute(&varscopenames), ::core::mem::transmute(&varoperations), ::core::mem::transmute(&varparameternames), ::core::mem::transmute(&varparametervalues), ::core::mem::transmute(&varinterfacenames), ::core::mem::transmute(&varinterfaceflags), ::core::mem::transmute(&varinterfaces)) { @@ -2306,7 +2317,7 @@ impl IAzClientContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzClientContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzClientContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -2317,7 +2328,7 @@ impl IAzClientContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRoles, Impl: IAzClientContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarrolenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRoles, Impl: IAzClientContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarrolenames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRoles(::core::mem::transmute(&bstrscopename)) { @@ -2365,37 +2376,37 @@ impl IAzClientContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzClientContext2_Impl: Sized + IAzClientContext_Impl { - fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut super::super::System::Variant::VARIANT, pvarscopenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddRoles(&self, varroles: &super::super::System::Variant::VARIANT, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddApplicationGroups(&self, varapplicationgroups: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddStringSids(&self, varstringsids: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut ::windows_core::VARIANT, pvarscopenames: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddRoles(&self, varroles: &::windows_core::VARIANT, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn AddApplicationGroups(&self, varapplicationgroups: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddStringSids(&self, varstringsids: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetLDAPQueryDN(&self, bstrldapquerydn: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn LDAPQueryDN(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzClientContext2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzClientContext2_Vtbl { pub const fn new, Impl: IAzClientContext2_Impl, const OFFSET: isize>() -> IAzClientContext2_Vtbl { - unsafe extern "system" fn GetAssignedScopesPage, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, loptions: i32, pagesize: i32, pvarcursor: *mut super::super::System::Variant::VARIANT, pvarscopenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAssignedScopesPage, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, loptions: i32, pagesize: i32, pvarcursor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarscopenames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetAssignedScopesPage(::core::mem::transmute_copy(&loptions), ::core::mem::transmute_copy(&pagesize), ::core::mem::transmute_copy(&pvarcursor), ::core::mem::transmute_copy(&pvarscopenames)).into() } - unsafe extern "system" fn AddRoles, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varroles: super::super::System::Variant::VARIANT, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddRoles, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varroles: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddRoles(::core::mem::transmute(&varroles), ::core::mem::transmute(&bstrscopename)).into() } - unsafe extern "system" fn AddApplicationGroups, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varapplicationgroups: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddApplicationGroups, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varapplicationgroups: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddApplicationGroups(::core::mem::transmute(&varapplicationgroups)).into() } - unsafe extern "system" fn AddStringSids, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstringsids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddStringSids, Impl: IAzClientContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstringsids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddStringSids(::core::mem::transmute(&varstringsids)).into() @@ -2430,8 +2441,8 @@ impl IAzClientContext2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzClientContext3_Impl: Sized + IAzClientContext2_Impl { fn AccessCheck2(&self, bstrobjectname: &::windows_core::BSTR, bstrscopename: &::windows_core::BSTR, loperation: i32) -> ::windows_core::Result; fn IsInRoleAssignment(&self, bstrscopename: &::windows_core::BSTR, bstrrolename: &::windows_core::BSTR) -> ::windows_core::Result; @@ -2439,12 +2450,12 @@ pub trait IAzClientContext3_Impl: Sized + IAzClientContext2_Impl { fn GetTasks(&self, bstrscopename: &::windows_core::BSTR) -> ::windows_core::Result; fn BizRuleParameters(&self) -> ::windows_core::Result; fn BizRuleInterfaces(&self) -> ::windows_core::Result; - fn GetGroups(&self, bstrscopename: &::windows_core::BSTR, uloptions: &AZ_PROP_CONSTANTS) -> ::windows_core::Result; - fn Sids(&self) -> ::windows_core::Result; + fn GetGroups(&self, bstrscopename: &::windows_core::BSTR, uloptions: &AZ_PROP_CONSTANTS) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Sids(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzClientContext3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzClientContext3_Vtbl { pub const fn new, Impl: IAzClientContext3_Impl, const OFFSET: isize>() -> IAzClientContext3_Vtbl { unsafe extern "system" fn AccessCheck2, Impl: IAzClientContext3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrobjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, loperation: i32, plresult: *mut u32) -> ::windows_core::HRESULT { @@ -2513,7 +2524,7 @@ impl IAzClientContext3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetGroups, Impl: IAzClientContext3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, uloptions: u32, pgrouparray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetGroups, Impl: IAzClientContext3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, uloptions: u32, pgrouparray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetGroups(::core::mem::transmute(&bstrscopename), ::core::mem::transmute(&uloptions)) { @@ -2524,7 +2535,7 @@ impl IAzClientContext3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Sids, Impl: IAzClientContext3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstringsidarray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Sids, Impl: IAzClientContext3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstringsidarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Sids() { @@ -2551,15 +2562,15 @@ impl IAzClientContext3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzNameResolver_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn NameFromSid(&self, bstrsid: &::windows_core::BSTR, psidtype: *mut i32, pbstrname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; - fn NamesFromSids(&self, vsids: &super::super::System::Variant::VARIANT, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn NamesFromSids(&self, vsids: &::windows_core::VARIANT, pvsidtypes: *mut ::windows_core::VARIANT, pvnames: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzNameResolver {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzNameResolver_Vtbl { pub const fn new, Impl: IAzNameResolver_Impl, const OFFSET: isize>() -> IAzNameResolver_Vtbl { unsafe extern "system" fn NameFromSid, Impl: IAzNameResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, psidtype: *mut i32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2567,7 +2578,7 @@ impl IAzNameResolver_Vtbl { let this = (*this).get_impl(); this.NameFromSid(::core::mem::transmute(&bstrsid), ::core::mem::transmute_copy(&psidtype), ::core::mem::transmute_copy(&pbstrname)).into() } - unsafe extern "system" fn NamesFromSids, Impl: IAzNameResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vsids: super::super::System::Variant::VARIANT, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NamesFromSids, Impl: IAzNameResolver_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vsids: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvsidtypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvnames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.NamesFromSids(::core::mem::transmute(&vsids), ::core::mem::transmute_copy(&pvsidtypes), ::core::mem::transmute_copy(&pvnames)).into() @@ -2582,18 +2593,18 @@ impl IAzNameResolver_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzObjectPicker_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn GetPrincipals(&self, hparentwnd: super::super::Foundation::HWND, bstrtitle: &::windows_core::BSTR, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT, pvsids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetPrincipals(&self, hparentwnd: super::super::Foundation::HWND, bstrtitle: &::windows_core::BSTR, pvsidtypes: *mut ::windows_core::VARIANT, pvnames: *mut ::windows_core::VARIANT, pvsids: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzObjectPicker {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzObjectPicker_Vtbl { pub const fn new, Impl: IAzObjectPicker_Impl, const OFFSET: isize>() -> IAzObjectPicker_Vtbl { - unsafe extern "system" fn GetPrincipals, Impl: IAzObjectPicker_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hparentwnd: super::super::Foundation::HWND, bstrtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT, pvsids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPrincipals, Impl: IAzObjectPicker_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hparentwnd: super::super::Foundation::HWND, bstrtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvsidtypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvnames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvsids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPrincipals(::core::mem::transmute_copy(&hparentwnd), ::core::mem::transmute(&bstrtitle), ::core::mem::transmute_copy(&pvsidtypes), ::core::mem::transmute_copy(&pvnames), ::core::mem::transmute_copy(&pvsids)).into() @@ -2619,8 +2630,8 @@ impl IAzObjectPicker_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzOperation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2631,13 +2642,13 @@ pub trait IAzOperation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OperationID(&self) -> ::windows_core::Result; fn SetOperationID(&self, lprop: i32) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzOperation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzOperation_Vtbl { pub const fn new, Impl: IAzOperation_Impl, const OFFSET: isize>() -> IAzOperation_Vtbl { unsafe extern "system" fn Name, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2715,7 +2726,7 @@ impl IAzOperation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -2726,12 +2737,12 @@ impl IAzOperation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzOperation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() @@ -2756,14 +2767,14 @@ impl IAzOperation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzOperation2_Impl: Sized + IAzOperation_Impl { fn RoleAssignments(&self, bstrscopename: &::windows_core::BSTR, brecursive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzOperation2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzOperation2_Vtbl { pub const fn new, Impl: IAzOperation2_Impl, const OFFSET: isize>() -> IAzOperation2_Vtbl { unsafe extern "system" fn RoleAssignments, Impl: IAzOperation2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, brecursive: super::super::Foundation::VARIANT_BOOL, pproleassignments: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2783,19 +2794,19 @@ impl IAzOperation2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzOperations_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzOperations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzOperations_Vtbl { pub const fn new, Impl: IAzOperations_Impl, const OFFSET: isize>() -> IAzOperations_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -2839,15 +2850,15 @@ impl IAzOperations_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzPrincipalLocator_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn NameResolver(&self) -> ::windows_core::Result; fn ObjectPicker(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzPrincipalLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzPrincipalLocator_Vtbl { pub const fn new, Impl: IAzPrincipalLocator_Impl, const OFFSET: isize>() -> IAzPrincipalLocator_Vtbl { unsafe extern "system" fn NameResolver, Impl: IAzPrincipalLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppnameresolver: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2882,8 +2893,8 @@ impl IAzPrincipalLocator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRole_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2891,31 +2902,31 @@ pub trait IAzRole_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ApplicationData(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetApplicationData(&self, bstrapplicationdata: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddTask(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteTask(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddOperation(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteOperation(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteAppMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddTask(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteTask(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddOperation(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteOperation(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteMember(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AppMembers(&self) -> ::windows_core::Result; - fn Members(&self) -> ::windows_core::Result; - fn Operations(&self) -> ::windows_core::Result; - fn Tasks(&self) -> ::windows_core::Result; - fn AddPropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn MembersName(&self) -> ::windows_core::Result; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteMemberName(&self, bstrprop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRole {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRole_Vtbl { pub const fn new, Impl: IAzRole_Impl, const OFFSET: isize>() -> IAzRole_Vtbl { unsafe extern "system" fn Name, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2966,42 +2977,42 @@ impl IAzRole_Vtbl { let this = (*this).get_impl(); this.SetApplicationData(::core::mem::transmute(&bstrapplicationdata)).into() } - unsafe extern "system" fn AddAppMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddAppMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddAppMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteAppMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteAppMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteAppMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddTask, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddTask, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddTask(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteTask, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteTask, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteTask(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddOperation, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddOperation, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddOperation(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteOperation, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteOperation, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteOperation(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteMember, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteMember(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() @@ -3017,7 +3028,7 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -3028,12 +3039,12 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AppMembers, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AppMembers, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AppMembers() { @@ -3044,7 +3055,7 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Members, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Members, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Members() { @@ -3055,7 +3066,7 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Operations, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Operations, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Operations() { @@ -3066,7 +3077,7 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Tasks, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Tasks, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Tasks() { @@ -3077,32 +3088,32 @@ impl IAzRole_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPropertyItem, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddMemberName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddMemberName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteMemberName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteMemberName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteMemberName(::core::mem::transmute(&bstrprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn MembersName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn MembersName, Impl: IAzRole_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MembersName() { @@ -3148,17 +3159,17 @@ impl IAzRole_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRoleAssignment_Impl: Sized + IAzRole_Impl { fn AddRoleDefinition(&self, bstrroledefinition: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DeleteRoleDefinition(&self, bstrroledefinition: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RoleDefinitions(&self) -> ::windows_core::Result; fn Scope(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRoleAssignment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRoleAssignment_Vtbl { pub const fn new, Impl: IAzRoleAssignment_Impl, const OFFSET: isize>() -> IAzRoleAssignment_Vtbl { unsafe extern "system" fn AddRoleDefinition, Impl: IAzRoleAssignment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrroledefinition: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3205,19 +3216,19 @@ impl IAzRoleAssignment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRoleAssignments_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRoleAssignments {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRoleAssignments_Vtbl { pub const fn new, Impl: IAzRoleAssignments_Impl, const OFFSET: isize>() -> IAzRoleAssignments_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzRoleAssignments_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzRoleAssignments_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -3261,17 +3272,17 @@ impl IAzRoleAssignments_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRoleDefinition_Impl: Sized + IAzTask_Impl { fn RoleAssignments(&self, bstrscopename: &::windows_core::BSTR, brecursive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; fn AddRoleDefinition(&self, bstrroledefinition: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DeleteRoleDefinition(&self, bstrroledefinition: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RoleDefinitions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRoleDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRoleDefinition_Vtbl { pub const fn new, Impl: IAzRoleDefinition_Impl, const OFFSET: isize>() -> IAzRoleDefinition_Vtbl { unsafe extern "system" fn RoleAssignments, Impl: IAzRoleDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, brecursive: super::super::Foundation::VARIANT_BOOL, pproleassignments: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3318,19 +3329,19 @@ impl IAzRoleDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRoleDefinitions_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRoleDefinitions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRoleDefinitions_Vtbl { pub const fn new, Impl: IAzRoleDefinitions_Impl, const OFFSET: isize>() -> IAzRoleDefinitions_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzRoleDefinitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzRoleDefinitions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -3374,19 +3385,19 @@ impl IAzRoleDefinitions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzRoles_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzRoles {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzRoles_Vtbl { pub const fn new, Impl: IAzRoles_Impl, const OFFSET: isize>() -> IAzRoles_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzRoles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzRoles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -3430,8 +3441,8 @@ impl IAzRoles_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzScope_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3440,41 +3451,41 @@ pub trait IAzScope_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ApplicationData(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetApplicationData(&self, bstrapplicationdata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PolicyAdministrators(&self) -> ::windows_core::Result; - fn PolicyReaders(&self) -> ::windows_core::Result; - fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministrator(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReader(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ApplicationGroups(&self) -> ::windows_core::Result; - fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteApplicationGroup(&self, bstrgroupname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Roles(&self) -> ::windows_core::Result; - fn OpenRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteRole(&self, bstrrolename: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Tasks(&self) -> ::windows_core::Result; - fn OpenTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreateTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn DeleteTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OpenTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result; + fn DeleteTask(&self, bstrtaskname: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn CanBeDelegated(&self) -> ::windows_core::Result; fn BizrulesWritable(&self) -> ::windows_core::Result; - fn PolicyAdministratorsName(&self) -> ::windows_core::Result; - fn PolicyReadersName(&self) -> ::windows_core::Result; - fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddPolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyAdministratorName(&self, bstradmin: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePolicyReaderName(&self, bstrreader: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzScope {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzScope_Vtbl { pub const fn new, Impl: IAzScope_Impl, const OFFSET: isize>() -> IAzScope_Vtbl { unsafe extern "system" fn Name, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3536,7 +3547,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -3547,22 +3558,22 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPropertyItem, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn PolicyAdministrators, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministrators, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministrators() { @@ -3573,7 +3584,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReaders, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReaders, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReaders() { @@ -3584,22 +3595,22 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministrator, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministrator, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministrator(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReader, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReader, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReader, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReader, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReader(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() @@ -3615,7 +3626,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -3626,7 +3637,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)) { @@ -3637,7 +3648,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteApplicationGroup, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteApplicationGroup(::core::mem::transmute(&bstrgroupname), ::core::mem::transmute(&varreserved)).into() @@ -3653,7 +3664,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)) { @@ -3664,7 +3675,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)) { @@ -3675,7 +3686,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteRole, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteRole(::core::mem::transmute(&bstrrolename), ::core::mem::transmute(&varreserved)).into() @@ -3691,7 +3702,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OpenTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn OpenTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OpenTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)) { @@ -3702,7 +3713,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)) { @@ -3713,12 +3724,12 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DeleteTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteTask, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteTask(::core::mem::transmute(&bstrtaskname), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() @@ -3745,7 +3756,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyAdministratorsName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyAdministratorsName() { @@ -3756,7 +3767,7 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolicyReadersName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolicyReadersName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolicyReadersName() { @@ -3767,22 +3778,22 @@ impl IAzScope_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyAdministratorName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyAdministratorName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyAdministratorName(::core::mem::transmute(&bstradmin), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPolicyReaderName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPolicyReaderName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePolicyReaderName, Impl: IAzScope_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePolicyReaderName(::core::mem::transmute(&bstrreader), ::core::mem::transmute(&varreserved)).into() @@ -3833,8 +3844,8 @@ impl IAzScope_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzScope2_Impl: Sized + IAzScope_Impl { fn RoleDefinitions(&self) -> ::windows_core::Result; fn CreateRoleDefinition(&self, bstrroledefinitionname: &::windows_core::BSTR) -> ::windows_core::Result; @@ -3845,9 +3856,9 @@ pub trait IAzScope2_Impl: Sized + IAzScope_Impl { fn OpenRoleAssignment(&self, bstrroleassignmentname: &::windows_core::BSTR) -> ::windows_core::Result; fn DeleteRoleAssignment(&self, bstrroleassignmentname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzScope2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzScope2_Vtbl { pub const fn new, Impl: IAzScope2_Impl, const OFFSET: isize>() -> IAzScope2_Vtbl { unsafe extern "system" fn RoleDefinitions, Impl: IAzScope2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pproledefinitions: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3942,19 +3953,19 @@ impl IAzScope2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzScopes_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzScopes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzScopes_Vtbl { pub const fn new, Impl: IAzScopes_Impl, const OFFSET: isize>() -> IAzScopes_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzScopes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzScopes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -3998,8 +4009,8 @@ impl IAzScopes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzTask_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4015,22 +4026,22 @@ pub trait IAzTask_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetBizRuleImportedPath(&self, bstrprop: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsRoleDefinition(&self) -> ::windows_core::Result; fn SetIsRoleDefinition(&self, fprop: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn Operations(&self) -> ::windows_core::Result; - fn Tasks(&self) -> ::windows_core::Result; - fn AddOperation(&self, bstrop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteOperation(&self, bstrop: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddTask(&self, bstrtask: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeleteTask(&self, bstrtask: &::windows_core::BSTR, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn AddOperation(&self, bstrop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteOperation(&self, bstrop: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddTask(&self, bstrtask: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeleteTask(&self, bstrtask: &::windows_core::BSTR, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Writable(&self) -> ::windows_core::Result; - fn GetProperty(&self, lpropid: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddPropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn DeletePropertyItem(&self, lpropid: i32, varprop: &super::super::System::Variant::VARIANT, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Submit(&self, lflags: i32, varreserved: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lpropid: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddPropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn DeletePropertyItem(&self, lpropid: i32, varprop: &::windows_core::VARIANT, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Submit(&self, lflags: i32, varreserved: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzTask {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzTask_Vtbl { pub const fn new, Impl: IAzTask_Impl, const OFFSET: isize>() -> IAzTask_Vtbl { unsafe extern "system" fn Name, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4145,7 +4156,7 @@ impl IAzTask_Vtbl { let this = (*this).get_impl(); this.SetIsRoleDefinition(::core::mem::transmute_copy(&fprop)).into() } - unsafe extern "system" fn Operations, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Operations, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Operations() { @@ -4156,7 +4167,7 @@ impl IAzTask_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Tasks, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Tasks, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Tasks() { @@ -4167,22 +4178,22 @@ impl IAzTask_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddOperation, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddOperation, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddOperation(::core::mem::transmute(&bstrop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteOperation, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteOperation, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteOperation(::core::mem::transmute(&bstrop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddTask, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddTask, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddTask(::core::mem::transmute(&bstrtask), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeleteTask, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteTask, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteTask(::core::mem::transmute(&bstrtask), ::core::mem::transmute(&varreserved)).into() @@ -4198,7 +4209,7 @@ impl IAzTask_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProperty, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varreserved)) { @@ -4209,22 +4220,22 @@ impl IAzTask_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn AddPropertyItem, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddPropertyItem, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddPropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn DeletePropertyItem, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeletePropertyItem, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeletePropertyItem(::core::mem::transmute_copy(&lpropid), ::core::mem::transmute(&varprop), ::core::mem::transmute(&varreserved)).into() } - unsafe extern "system" fn Submit, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Submit, Impl: IAzTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Submit(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&varreserved)).into() @@ -4263,14 +4274,14 @@ impl IAzTask_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzTask2_Impl: Sized + IAzTask_Impl { fn RoleAssignments(&self, bstrscopename: &::windows_core::BSTR, brecursive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzTask2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzTask2_Vtbl { pub const fn new, Impl: IAzTask2_Impl, const OFFSET: isize>() -> IAzTask2_Vtbl { unsafe extern "system" fn RoleAssignments, Impl: IAzTask2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, brecursive: super::super::Foundation::VARIANT_BOOL, pproleassignments: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4290,19 +4301,19 @@ impl IAzTask2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAzTasks_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAzTasks {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAzTasks_Vtbl { pub const fn new, Impl: IAzTasks_Impl, const OFFSET: isize>() -> IAzTasks_Vtbl { - unsafe extern "system" fn get_Item, Impl: IAzTasks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IAzTasks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { diff --git a/crates/libs/windows/src/Windows/Win32/Security/Authorization/mod.rs b/crates/libs/windows/src/Windows/Win32/Security/Authorization/mod.rs index 7e2ddd3810..75b46abd9f 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Authorization/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Authorization/mod.rs @@ -789,60 +789,55 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -850,31 +845,32 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Scopes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -882,31 +878,32 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -914,31 +911,32 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -946,31 +944,32 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -978,159 +977,154 @@ impl IAzApplication { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Roles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1153,190 +1147,106 @@ pub struct IAzApplication_Vtbl { pub ApplyStoreSacl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetApplyStoreSacl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bprop: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministrators: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReaders: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReader: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReader: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Scopes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppscopecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Scopes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenScope: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppscope: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateScope: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteScope: usize, + pub DeleteScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Operations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppoperationcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Operations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppoperation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteOperation: usize, + pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstroperationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pptaskcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Tasks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteTask: usize, + pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub ApplicationGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppgroupcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ApplicationGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteApplicationGroup: usize, + pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Roles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprolecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Roles: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeClientContextFromToken: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulltokenhandle: u64, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub DeleteRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub InitializeClientContextFromToken: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulltokenhandle: u64, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InitializeClientContextFromToken: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeClientContextFromName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, clientname: ::std::mem::MaybeUninit<::windows_core::BSTR>, domainname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub InitializeClientContextFromName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, clientname: ::std::mem::MaybeUninit<::windows_core::BSTR>, domainname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InitializeClientContextFromName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DelegatedPolicyUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DelegatedPolicyUsers: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddDelegatedPolicyUser: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteDelegatedPolicyUser: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeClientContextFromStringSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sidstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: i32, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub DelegatedPolicyUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub InitializeClientContextFromStringSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sidstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InitializeClientContextFromStringSid: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministratorsName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReadersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReaderName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReaderName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DelegatedPolicyUsersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DelegatedPolicyUsersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddDelegatedPolicyUserName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteDelegatedPolicyUserName: usize, + pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DelegatedPolicyUsersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1423,60 +1333,55 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1484,31 +1389,32 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Scopes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1516,31 +1422,32 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1548,31 +1455,32 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1580,31 +1488,32 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1612,174 +1521,173 @@ impl IAzApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Roles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).InitializeClientContextFromToken2)(::windows_core::Interface::as_raw(self), ultokenhandlelowpart, ultokenhandlehighpart, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).InitializeClientContextFromToken2)(::windows_core::Interface::as_raw(self), ultokenhandlelowpart, ultokenhandlehighpart, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContext2(&self, identifyingstring: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContext2(&self, identifyingstring: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).InitializeClientContext2)(::windows_core::Interface::as_raw(self), identifyingstring.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).InitializeClientContext2)(::windows_core::Interface::as_raw(self), identifyingstring.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -1787,13 +1695,13 @@ impl IAzApplication2 { #[doc(hidden)] pub struct IAzApplication2_Vtbl { pub base__: IAzApplication_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeClientContextFromToken2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub InitializeClientContextFromToken2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InitializeClientContextFromToken2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeClientContext2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifyingstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub InitializeClientContext2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifyingstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppclientcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InitializeClientContext2: usize, } #[cfg(feature = "Win32_System_Com")] @@ -1881,60 +1789,55 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1942,31 +1845,32 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Scopes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteScope(&self, bstrscopename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteScope)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1974,31 +1878,32 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstroperationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstroperationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2006,31 +1911,32 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2038,31 +1944,32 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2070,174 +1977,173 @@ impl IAzApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Roles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromToken(&self, ulltokenhandle: u64, varreserved: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromToken)(::windows_core::Interface::as_raw(self), ulltokenhandle, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromName(&self, clientname: P0, domainname: P1, varreserved: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromName)(::windows_core::Interface::as_raw(self), clientname.into_param().abi(), domainname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromStringSid(&self, sidstring: P0, loptions: i32, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.InitializeClientContextFromStringSid)(::windows_core::Interface::as_raw(self), sidstring.into_param().abi(), loptions, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContextFromToken2(&self, ultokenhandlelowpart: u32, ultokenhandlehighpart: u32, varreserved: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromToken2)(::windows_core::Interface::as_raw(self), ultokenhandlelowpart, ultokenhandlehighpart, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.InitializeClientContextFromToken2)(::windows_core::Interface::as_raw(self), ultokenhandlelowpart, ultokenhandlehighpart, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeClientContext2(&self, identifyingstring: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InitializeClientContext2(&self, identifyingstring: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.InitializeClientContext2)(::windows_core::Interface::as_raw(self), identifyingstring.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.InitializeClientContext2)(::windows_core::Interface::as_raw(self), identifyingstring.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ScopeExists(&self, bstrscopename: P0) -> ::windows_core::Result where @@ -2423,27 +2329,19 @@ impl IAzApplicationGroup { { (::windows_core::Interface::vtable(self).SetLdapQuery)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AppMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppNonMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppNonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AppNonMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Members(&self) -> ::windows_core::Result { + pub unsafe fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Members)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NonMembers(&self) -> ::windows_core::Result { + pub unsafe fn NonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NonMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2457,141 +2355,133 @@ impl IAzApplicationGroup { { (::windows_core::Interface::vtable(self).SetDescription)(::windows_core::Interface::as_raw(self), bstrdescription.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddNonMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddNonMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteNonMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteNonMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MembersName(&self) -> ::windows_core::Result { + pub unsafe fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NonMembersName(&self) -> ::windows_core::Result { + pub unsafe fn NonMembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NonMembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2607,101 +2497,32 @@ pub struct IAzApplicationGroup_Vtbl { pub SetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lprop: i32) -> ::windows_core::HRESULT, pub LdapQuery: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetLdapQuery: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AppMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AppMembers: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AppNonMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AppNonMembers: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Members: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Members: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NonMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NonMembers: usize, + pub AppMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AppNonMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Members: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub NonMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddAppMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteAppMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddAppNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddAppNonMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteAppNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteAppNonMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddNonMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteNonMember: usize, + pub AddAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddAppNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteAppNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteNonMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddNonMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddNonMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteNonMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteNonMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MembersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NonMembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NonMembersName: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddNonMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteNonMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub MembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub NonMembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2741,27 +2562,19 @@ impl IAzApplicationGroup2 { { (::windows_core::Interface::vtable(self).base__.SetLdapQuery)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.AppMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppNonMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppNonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.AppNonMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Members(&self) -> ::windows_core::Result { + pub unsafe fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Members)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NonMembers(&self) -> ::windows_core::Result { + pub unsafe fn NonMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.NonMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2775,141 +2588,133 @@ impl IAzApplicationGroup2 { { (::windows_core::Interface::vtable(self).base__.SetDescription)(::windows_core::Interface::as_raw(self), bstrdescription.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteAppNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteNonMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteNonMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteNonMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddNonMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddNonMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteNonMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteNonMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteNonMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MembersName(&self) -> ::windows_core::Result { + pub unsafe fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NonMembersName(&self) -> ::windows_core::Result { + pub unsafe fn NonMembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.NonMembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2981,9 +2786,7 @@ pub struct IAzApplicationGroup2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzApplicationGroups, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzApplicationGroups { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -3001,10 +2804,7 @@ impl IAzApplicationGroups { #[doc(hidden)] pub struct IAzApplicationGroups_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -3019,9 +2819,7 @@ pub struct IAzApplicationGroups_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzApplications, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzApplications { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -3039,10 +2837,7 @@ impl IAzApplications { #[doc(hidden)] pub struct IAzApplications_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -3112,88 +2907,88 @@ impl IAzAuthorizationStore { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UpdateCache(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).UpdateCache)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn UpdateCache(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).UpdateCache)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Delete(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Delete(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3201,31 +2996,32 @@ impl IAzAuthorizationStore { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Applications)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3233,58 +3029,56 @@ impl IAzAuthorizationStore { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn TargetMachine(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3300,71 +3094,59 @@ impl IAzAuthorizationStore { { (::windows_core::Interface::vtable(self).SetApplyStoreSacl)(::windows_core::Interface::as_raw(self), bapplystoresacl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn CloseApplication(&self, bstrapplicationname: P0, lflag: i32) -> ::windows_core::Result<()> where @@ -3391,145 +3173,61 @@ pub struct IAzAuthorizationStore_Vtbl { pub GenerateAudits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetGenerateAudits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bprop: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: AZ_PROP_CONSTANTS, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministrators: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReaders: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReader: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReader: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Initialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Initialize: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UpdateCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UpdateCache: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Delete: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: AZ_PROP_CONSTANTS, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Initialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub UpdateCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Applications: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppappcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Applications: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenApplication: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateApplication: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteApplication: usize, + pub DeleteApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub ApplicationGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppgroupcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ApplicationGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DelegatedPolicyUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DelegatedPolicyUsers: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddDelegatedPolicyUser: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteDelegatedPolicyUser: usize, + pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DelegatedPolicyUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteDelegatedPolicyUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub TargetMachine: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrtargetmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ApplyStoreSacl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbapplystoresacl: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetApplyStoreSacl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bapplystoresacl: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministratorsName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReadersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReaderName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReaderName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DelegatedPolicyUsersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DelegatedPolicyUsersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddDelegatedPolicyUserName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteDelegatedPolicyUserName: usize, + pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DelegatedPolicyUsersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardelegatedpolicyusers: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteDelegatedPolicyUserName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdelegatedpolicyuser: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub CloseApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, lflag: i32) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -3598,88 +3296,88 @@ impl IAzAuthorizationStore2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UpdateCache(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.UpdateCache)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn UpdateCache(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.UpdateCache)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Delete(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Delete)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Delete(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Delete)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3687,31 +3385,32 @@ impl IAzAuthorizationStore2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Applications)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3719,58 +3418,56 @@ impl IAzAuthorizationStore2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn TargetMachine(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3786,71 +3483,59 @@ impl IAzAuthorizationStore2 { { (::windows_core::Interface::vtable(self).base__.SetApplyStoreSacl)(::windows_core::Interface::as_raw(self), bapplystoresacl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn CloseApplication(&self, bstrapplicationname: P0, lflag: i32) -> ::windows_core::Result<()> where @@ -3858,23 +3543,25 @@ impl IAzAuthorizationStore2 { { (::windows_core::Interface::vtable(self).base__.CloseApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), lflag).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplication2(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplication2(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplication2(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplication2(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3882,13 +3569,13 @@ impl IAzAuthorizationStore2 { #[doc(hidden)] pub struct IAzAuthorizationStore2_Vtbl { pub base__: IAzAuthorizationStore_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenApplication2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenApplication2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenApplication2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateApplication2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateApplication2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppapplication: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateApplication2: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3957,88 +3644,88 @@ impl IAzAuthorizationStore3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: AZ_PROP_CONSTANTS, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Initialize(&self, lflags: AZ_PROP_CONSTANTS, bstrpolicyurl: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.Initialize)(::windows_core::Interface::as_raw(self), lflags, bstrpolicyurl.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UpdateCache(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.UpdateCache)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn UpdateCache(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.UpdateCache)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Delete(&self, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Delete)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Delete(&self, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Delete)(::windows_core::Interface::as_raw(self), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4046,31 +3733,32 @@ impl IAzAuthorizationStore3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Applications)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplication(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4078,58 +3766,56 @@ impl IAzAuthorizationStore3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.DelegatedPolicyUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUser(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUser)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn TargetMachine(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4145,71 +3831,59 @@ impl IAzAuthorizationStore3 { { (::windows_core::Interface::vtable(self).base__.base__.SetApplyStoreSacl)(::windows_core::Interface::as_raw(self), bapplystoresacl.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result { + pub unsafe fn DelegatedPolicyUsersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.DelegatedPolicyUsersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteDelegatedPolicyUserName(&self, bstrdelegatedpolicyuser: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.base__.DeleteDelegatedPolicyUserName)(::windows_core::Interface::as_raw(self), bstrdelegatedpolicyuser.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn CloseApplication(&self, bstrapplicationname: P0, lflag: i32) -> ::windows_core::Result<()> where @@ -4217,23 +3891,25 @@ impl IAzAuthorizationStore3 { { (::windows_core::Interface::vtable(self).base__.base__.CloseApplication)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), lflag).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplication2(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplication2(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplication2(&self, bstrapplicationname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplication2(&self, bstrapplicationname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateApplication2)(::windows_core::Interface::as_raw(self), bstrapplicationname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn IsUpdateNeeded(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4292,9 +3968,7 @@ impl IAzBizRuleContext { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BusinessRuleString)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameter(&self, bstrparametername: P0) -> ::windows_core::Result + pub unsafe fn GetParameter(&self, bstrparametername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4310,10 +3984,7 @@ pub struct IAzBizRuleContext_Vtbl { pub SetBusinessRuleResult: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bresult: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetBusinessRuleString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbusinessrulestring: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BusinessRuleString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrbusinessrulestring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameter: usize, + pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4326,26 +3997,26 @@ pub struct IAzBizRuleContext_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzBizRuleInterfaces, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzBizRuleInterfaces { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddInterface(&self, bstrinterfacename: P0, linterfaceflag: i32, varinterface: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddInterface(&self, bstrinterfacename: P0, linterfaceflag: i32, varinterface: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddInterface)(::windows_core::Interface::as_raw(self), bstrinterfacename.into_param().abi(), linterfaceflag, ::core::mem::transmute(varinterface)).ok() + (::windows_core::Interface::vtable(self).AddInterface)(::windows_core::Interface::as_raw(self), bstrinterfacename.into_param().abi(), linterfaceflag, varinterface.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddInterfaces(&self, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddInterfaces)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varinterfacenames), ::core::mem::transmute(varinterfaceflags), ::core::mem::transmute(varinterfaces)).ok() + pub unsafe fn AddInterfaces(&self, varinterfacenames: P0, varinterfaceflags: P1, varinterfaces: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddInterfaces)(::windows_core::Interface::as_raw(self), varinterfacenames.into_param().abi(), varinterfaceflags.into_param().abi(), varinterfaces.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInterfaceValue(&self, bstrinterfacename: P0, linterfaceflag: *mut i32, varinterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetInterfaceValue(&self, bstrinterfacename: P0, linterfaceflag: *mut i32, varinterface: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetInterfaceValue)(::windows_core::Interface::as_raw(self), bstrinterfacename.into_param().abi(), linterfaceflag, varinterface).ok() + (::windows_core::Interface::vtable(self).GetInterfaceValue)(::windows_core::Interface::as_raw(self), bstrinterfacename.into_param().abi(), linterfaceflag, ::core::mem::transmute(varinterface)).ok() } pub unsafe fn Remove(&self, bstrinterfacename: P0) -> ::windows_core::Result<()> where @@ -4366,18 +4037,9 @@ impl IAzBizRuleInterfaces { #[doc(hidden)] pub struct IAzBizRuleInterfaces_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: i32, varinterface: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddInterface: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddInterfaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetInterfaceValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: *mut i32, varinterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetInterfaceValue: usize, + pub AddInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: i32, varinterface: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinterfacenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaceflags: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetInterfaceValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, linterfaceflag: *mut i32, varinterface: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrinterfacename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RemoveAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut u32) -> ::windows_core::HRESULT, @@ -4393,22 +4055,21 @@ pub struct IAzBizRuleInterfaces_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzBizRuleParameters, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzBizRuleParameters { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddParameter(&self, bstrparametername: P0, varparametervalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddParameter(&self, bstrparametername: P0, varparametervalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddParameter)(::windows_core::Interface::as_raw(self), bstrparametername.into_param().abi(), ::core::mem::transmute(varparametervalue)).ok() + (::windows_core::Interface::vtable(self).AddParameter)(::windows_core::Interface::as_raw(self), bstrparametername.into_param().abi(), varparametervalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddParameters(&self, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddParameters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varparameternames), ::core::mem::transmute(varparametervalues)).ok() + pub unsafe fn AddParameters(&self, varparameternames: P0, varparametervalues: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddParameters)(::windows_core::Interface::as_raw(self), varparameternames.into_param().abi(), varparametervalues.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameterValue(&self, bstrparametername: P0) -> ::windows_core::Result + pub unsafe fn GetParameterValue(&self, bstrparametername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4434,18 +4095,9 @@ impl IAzBizRuleParameters { #[doc(hidden)] pub struct IAzBizRuleParameters_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, varparametervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddParameter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddParameters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParameterValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParameterValue: usize, + pub AddParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, varparametervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varparameternames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varparametervalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetParameterValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarparametervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varparametername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RemoveAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut u32) -> ::windows_core::HRESULT, @@ -4461,14 +4113,19 @@ pub struct IAzBizRuleParameters_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzClientContext, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzClientContext { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: super::super::System::Variant::VARIANT, varoperations: super::super::System::Variant::VARIANT, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: P1, varoperations: P2, varparameternames: P3, varparametervalues: P4, varinterfacenames: P5, varinterfaceflags: P6, varinterfaces: P7) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, + P5: ::windows_core::IntoParam<::windows_core::VARIANT>, + P6: ::windows_core::IntoParam<::windows_core::VARIANT>, + P7: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), ::core::mem::transmute(varscopenames), ::core::mem::transmute(varoperations), ::core::mem::transmute(varparameternames), ::core::mem::transmute(varparametervalues), ::core::mem::transmute(varinterfacenames), ::core::mem::transmute(varinterfaceflags), ::core::mem::transmute(varinterfaces), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), varscopenames.into_param().abi(), varoperations.into_param().abi(), varparameternames.into_param().abi(), varparametervalues.into_param().abi(), varinterfacenames.into_param().abi(), varinterfaceflags.into_param().abi(), varinterfaces.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetBusinessRuleString(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4502,15 +4159,14 @@ impl IAzClientContext { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).UserDnsSamCompat)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result + pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4533,10 +4189,7 @@ impl IAzClientContext { #[doc(hidden)] pub struct IAzClientContext_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AccessCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrobjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varscopenames: super::super::System::Variant::VARIANT, varoperations: super::super::System::Variant::VARIANT, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT, pvarresults: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AccessCheck: usize, + pub AccessCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrobjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varscopenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varoperations: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varparameternames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varparametervalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfacenames: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaceflags: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varinterfaces: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarresults: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetBusinessRuleString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrbusinessrulestring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub UserDn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub UserSamCompat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -4545,14 +4198,8 @@ pub struct IAzClientContext_Vtbl { pub UserCanonical: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub UserUpn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub UserDnsSamCompat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRoles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarrolenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetRoles: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetRoles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarrolenames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RoleForAccessCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrprop: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetRoleForAccessCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -4567,14 +4214,19 @@ pub struct IAzClientContext_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzClientContext2, ::windows_core::IUnknown, super::super::System::Com::IDispatch, IAzClientContext); #[cfg(feature = "Win32_System_Com")] impl IAzClientContext2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: super::super::System::Variant::VARIANT, varoperations: super::super::System::Variant::VARIANT, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: P1, varoperations: P2, varparameternames: P3, varparametervalues: P4, varinterfacenames: P5, varinterfaceflags: P6, varinterfaces: P7) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, + P5: ::windows_core::IntoParam<::windows_core::VARIANT>, + P6: ::windows_core::IntoParam<::windows_core::VARIANT>, + P7: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), ::core::mem::transmute(varscopenames), ::core::mem::transmute(varoperations), ::core::mem::transmute(varparameternames), ::core::mem::transmute(varparametervalues), ::core::mem::transmute(varinterfacenames), ::core::mem::transmute(varinterfaceflags), ::core::mem::transmute(varinterfaces), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), varscopenames.into_param().abi(), varoperations.into_param().abi(), varparameternames.into_param().abi(), varparametervalues.into_param().abi(), varinterfacenames.into_param().abi(), varinterfaceflags.into_param().abi(), varinterfaces.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetBusinessRuleString(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4608,15 +4260,14 @@ impl IAzClientContext2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.UserDnsSamCompat)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result + pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4633,28 +4284,27 @@ impl IAzClientContext2 { { (::windows_core::Interface::vtable(self).base__.SetRoleForAccessCheck)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut super::super::System::Variant::VARIANT, pvarscopenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetAssignedScopesPage)(::windows_core::Interface::as_raw(self), loptions, pagesize, pvarcursor, pvarscopenames).ok() + pub unsafe fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut ::windows_core::VARIANT, pvarscopenames: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetAssignedScopesPage)(::windows_core::Interface::as_raw(self), loptions, pagesize, ::core::mem::transmute(pvarcursor), ::core::mem::transmute(pvarscopenames)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddRoles(&self, varroles: super::super::System::Variant::VARIANT, bstrscopename: P0) -> ::windows_core::Result<()> + pub unsafe fn AddRoles(&self, varroles: P0, bstrscopename: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddRoles)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varroles), bstrscopename.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).AddRoles)(::windows_core::Interface::as_raw(self), varroles.into_param().abi(), bstrscopename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddApplicationGroups(&self, varapplicationgroups: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddApplicationGroups)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varapplicationgroups)).ok() + pub unsafe fn AddApplicationGroups(&self, varapplicationgroups: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddApplicationGroups)(::windows_core::Interface::as_raw(self), varapplicationgroups.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddStringSids(&self, varstringsids: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddStringSids)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstringsids)).ok() + pub unsafe fn AddStringSids(&self, varstringsids: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddStringSids)(::windows_core::Interface::as_raw(self), varstringsids.into_param().abi()).ok() } pub unsafe fn SetLDAPQueryDN(&self, bstrldapquerydn: P0) -> ::windows_core::Result<()> where @@ -4672,22 +4322,10 @@ impl IAzClientContext2 { #[doc(hidden)] pub struct IAzClientContext2_Vtbl { pub base__: IAzClientContext_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAssignedScopesPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, loptions: i32, pagesize: i32, pvarcursor: *mut super::super::System::Variant::VARIANT, pvarscopenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAssignedScopesPage: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddRoles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varroles: super::super::System::Variant::VARIANT, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddRoles: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddApplicationGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varapplicationgroups: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddApplicationGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddStringSids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstringsids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddStringSids: usize, + pub GetAssignedScopesPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, loptions: i32, pagesize: i32, pvarcursor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarscopenames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddRoles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varroles: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub AddApplicationGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varapplicationgroups: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddStringSids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstringsids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetLDAPQueryDN: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrldapquerydn: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LDAPQueryDN: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrldapquerydn: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -4702,14 +4340,19 @@ pub struct IAzClientContext2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzClientContext3, ::windows_core::IUnknown, super::super::System::Com::IDispatch, IAzClientContext, IAzClientContext2); #[cfg(feature = "Win32_System_Com")] impl IAzClientContext3 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: super::super::System::Variant::VARIANT, varoperations: super::super::System::Variant::VARIANT, varparameternames: super::super::System::Variant::VARIANT, varparametervalues: super::super::System::Variant::VARIANT, varinterfacenames: super::super::System::Variant::VARIANT, varinterfaceflags: super::super::System::Variant::VARIANT, varinterfaces: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn AccessCheck(&self, bstrobjectname: P0, varscopenames: P1, varoperations: P2, varparameternames: P3, varparametervalues: P4, varinterfacenames: P5, varinterfaceflags: P6, varinterfaces: P7) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, + P5: ::windows_core::IntoParam<::windows_core::VARIANT>, + P6: ::windows_core::IntoParam<::windows_core::VARIANT>, + P7: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), ::core::mem::transmute(varscopenames), ::core::mem::transmute(varoperations), ::core::mem::transmute(varparameternames), ::core::mem::transmute(varparametervalues), ::core::mem::transmute(varinterfacenames), ::core::mem::transmute(varinterfaceflags), ::core::mem::transmute(varinterfaces), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.AccessCheck)(::windows_core::Interface::as_raw(self), bstrobjectname.into_param().abi(), varscopenames.into_param().abi(), varoperations.into_param().abi(), varparameternames.into_param().abi(), varparametervalues.into_param().abi(), varinterfacenames.into_param().abi(), varinterfaceflags.into_param().abi(), varinterfaces.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetBusinessRuleString(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4743,15 +4386,14 @@ impl IAzClientContext3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.UserDnsSamCompat)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result + pub unsafe fn GetRoles(&self, bstrscopename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4768,28 +4410,27 @@ impl IAzClientContext3 { { (::windows_core::Interface::vtable(self).base__.base__.SetRoleForAccessCheck)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut super::super::System::Variant::VARIANT, pvarscopenames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetAssignedScopesPage)(::windows_core::Interface::as_raw(self), loptions, pagesize, pvarcursor, pvarscopenames).ok() + pub unsafe fn GetAssignedScopesPage(&self, loptions: i32, pagesize: i32, pvarcursor: *mut ::windows_core::VARIANT, pvarscopenames: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetAssignedScopesPage)(::windows_core::Interface::as_raw(self), loptions, pagesize, ::core::mem::transmute(pvarcursor), ::core::mem::transmute(pvarscopenames)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddRoles(&self, varroles: super::super::System::Variant::VARIANT, bstrscopename: P0) -> ::windows_core::Result<()> + pub unsafe fn AddRoles(&self, varroles: P0, bstrscopename: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.AddRoles)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varroles), bstrscopename.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.AddRoles)(::windows_core::Interface::as_raw(self), varroles.into_param().abi(), bstrscopename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddApplicationGroups(&self, varapplicationgroups: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddApplicationGroups)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varapplicationgroups)).ok() + pub unsafe fn AddApplicationGroups(&self, varapplicationgroups: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddApplicationGroups)(::windows_core::Interface::as_raw(self), varapplicationgroups.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddStringSids(&self, varstringsids: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddStringSids)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstringsids)).ok() + pub unsafe fn AddStringSids(&self, varstringsids: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddStringSids)(::windows_core::Interface::as_raw(self), varstringsids.into_param().abi()).ok() } pub unsafe fn SetLDAPQueryDN(&self, bstrldapquerydn: P0) -> ::windows_core::Result<()> where @@ -4847,18 +4488,14 @@ impl IAzClientContext3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BizRuleInterfaces)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetGroups(&self, bstrscopename: P0, uloptions: AZ_PROP_CONSTANTS) -> ::windows_core::Result + pub unsafe fn GetGroups(&self, bstrscopename: P0, uloptions: AZ_PROP_CONSTANTS) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetGroups)(::windows_core::Interface::as_raw(self), bstrscopename.into_param().abi(), uloptions.0 as _, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Sids(&self) -> ::windows_core::Result { + pub unsafe fn Sids(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Sids)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4886,14 +4523,8 @@ pub struct IAzClientContext3_Vtbl { pub BizRuleInterfaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppbizruleinterfaces: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] BizRuleInterfaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, uloptions: u32, pgrouparray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Sids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstringsidarray: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Sids: usize, + pub GetGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrscopename: ::std::mem::MaybeUninit<::windows_core::BSTR>, uloptions: u32, pgrouparray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Sids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstringsidarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4912,10 +4543,11 @@ impl IAzNameResolver { { (::windows_core::Interface::vtable(self).NameFromSid)(::windows_core::Interface::as_raw(self), bstrsid.into_param().abi(), psidtype, ::core::mem::transmute(pbstrname)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NamesFromSids(&self, vsids: super::super::System::Variant::VARIANT, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).NamesFromSids)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vsids), pvsidtypes, pvnames).ok() + pub unsafe fn NamesFromSids(&self, vsids: P0, pvsidtypes: *mut ::windows_core::VARIANT, pvnames: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).NamesFromSids)(::windows_core::Interface::as_raw(self), vsids.into_param().abi(), ::core::mem::transmute(pvsidtypes), ::core::mem::transmute(pvnames)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4924,10 +4556,7 @@ impl IAzNameResolver { pub struct IAzNameResolver_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub NameFromSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, psidtype: *mut i32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NamesFromSids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vsids: super::super::System::Variant::VARIANT, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NamesFromSids: usize, + pub NamesFromSids: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vsids: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvsidtypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvnames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4940,14 +4569,12 @@ pub struct IAzNameResolver_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzObjectPicker, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzObjectPicker { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPrincipals(&self, hparentwnd: P0, bstrtitle: P1, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT, pvsids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetPrincipals(&self, hparentwnd: P0, bstrtitle: P1, pvsidtypes: *mut ::windows_core::VARIANT, pvnames: *mut ::windows_core::VARIANT, pvsids: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetPrincipals)(::windows_core::Interface::as_raw(self), hparentwnd.into_param().abi(), bstrtitle.into_param().abi(), pvsidtypes, pvnames, pvsids).ok() + (::windows_core::Interface::vtable(self).GetPrincipals)(::windows_core::Interface::as_raw(self), hparentwnd.into_param().abi(), bstrtitle.into_param().abi(), ::core::mem::transmute(pvsidtypes), ::core::mem::transmute(pvnames), ::core::mem::transmute(pvsids)).ok() } pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -4959,10 +4586,7 @@ impl IAzObjectPicker { #[doc(hidden)] pub struct IAzObjectPicker_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPrincipals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hparentwnd: super::super::Foundation::HWND, bstrtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvsidtypes: *mut super::super::System::Variant::VARIANT, pvnames: *mut super::super::System::Variant::VARIANT, pvsids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPrincipals: usize, + pub GetPrincipals: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hparentwnd: super::super::Foundation::HWND, bstrtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvsidtypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvnames: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvsids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5017,21 +4641,25 @@ impl IAzOperation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5048,18 +4676,9 @@ pub struct IAzOperation_Vtbl { pub OperationID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plprop: *mut i32) -> ::windows_core::HRESULT, pub SetOperationID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lprop: i32) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5113,21 +4732,25 @@ impl IAzOperation2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5161,9 +4784,7 @@ pub struct IAzOperation2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzOperations, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzOperations { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -5181,10 +4802,7 @@ impl IAzOperations { #[doc(hidden)] pub struct IAzOperations_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -5267,143 +4885,131 @@ impl IAzRole { { (::windows_core::Interface::vtable(self).SetApplicationData)(::windows_core::Interface::as_raw(self), bstrapplicationdata.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddTask(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddTask(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOperation(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddOperation(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AppMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Members(&self) -> ::windows_core::Result { + pub unsafe fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Members)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operations(&self) -> ::windows_core::Result { + pub unsafe fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Tasks(&self) -> ::windows_core::Result { + pub unsafe fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MembersName(&self) -> ::windows_core::Result { + pub unsafe fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5419,87 +5025,27 @@ pub struct IAzRole_Vtbl { pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ApplicationData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrapplicationdata: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetApplicationData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationdata: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddAppMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteAppMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddMember: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteMember: usize, + pub AddAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteAppMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteMember: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AppMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AppMembers: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Members: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Members: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Operations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Operations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Tasks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteMemberName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MembersName: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AppMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Members: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Operations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteMemberName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub MembersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5542,143 +5088,131 @@ impl IAzRoleAssignment { { (::windows_core::Interface::vtable(self).base__.SetApplicationData)(::windows_core::Interface::as_raw(self), bstrapplicationdata.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteAppMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteAppMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddTask(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddTask(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOperation(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddOperation(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMember(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteMember)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AppMembers(&self) -> ::windows_core::Result { + pub unsafe fn AppMembers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.AppMembers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Members(&self) -> ::windows_core::Result { + pub unsafe fn Members(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Members)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operations(&self) -> ::windows_core::Result { + pub unsafe fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Tasks(&self) -> ::windows_core::Result { + pub unsafe fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteMemberName(&self, bstrprop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteMemberName)(::windows_core::Interface::as_raw(self), bstrprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MembersName(&self) -> ::windows_core::Result { + pub unsafe fn MembersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MembersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5734,9 +5268,7 @@ pub struct IAzRoleAssignment_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzRoleAssignments, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzRoleAssignments { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -5754,10 +5286,7 @@ impl IAzRoleAssignments { #[doc(hidden)] pub struct IAzRoleAssignments_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -5842,79 +5371,79 @@ impl IAzRoleDefinition { { (::windows_core::Interface::vtable(self).base__.SetIsRoleDefinition)(::windows_core::Interface::as_raw(self), fprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operations(&self) -> ::windows_core::Result { + pub unsafe fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Tasks(&self) -> ::windows_core::Result { + pub unsafe fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5972,9 +5501,7 @@ pub struct IAzRoleDefinition_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzRoleDefinitions, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzRoleDefinitions { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -5992,10 +5519,7 @@ impl IAzRoleDefinitions { #[doc(hidden)] pub struct IAzRoleDefinitions_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -6010,9 +5534,7 @@ pub struct IAzRoleDefinitions_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzRoles, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzRoles { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -6030,10 +5552,7 @@ impl IAzRoles { #[doc(hidden)] pub struct IAzRoles_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -6082,70 +5601,69 @@ impl IAzScope { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6153,31 +5671,32 @@ impl IAzScope { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6185,31 +5704,32 @@ impl IAzScope { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Roles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6217,36 +5737,38 @@ impl IAzScope { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } pub unsafe fn CanBeDelegated(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6256,49 +5778,41 @@ impl IAzScope { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BizrulesWritable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6313,124 +5827,64 @@ pub struct IAzScope_Vtbl { pub ApplicationData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrapplicationdata: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetApplicationData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationdata: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministrators: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReaders: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministrator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReader: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReader: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyAdministrators: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministrator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub ApplicationGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppgroupcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ApplicationGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateApplicationGroup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteApplicationGroup: usize, + pub DeleteApplicationGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Roles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprolecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Roles: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprole: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteRole: usize, + pub DeleteRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrolename: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pptaskcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Tasks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OpenTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OpenTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OpenTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, + pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtaskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub CanBeDelegated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub BizrulesWritable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyAdministratorsName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolicyReadersName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyAdministratorName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPolicyReaderName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePolicyReaderName: usize, + pub PolicyAdministratorsName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaradmins: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PolicyReadersName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarreaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyAdministratorName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstradmin: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePolicyReaderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrreader: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6477,70 +5931,69 @@ impl IAzScope2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministrators(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministrators)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministrator(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministrator)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReader(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReader)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6548,31 +6001,32 @@ impl IAzScope2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ApplicationGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteApplicationGroup(&self, bstrgroupname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteApplicationGroup)(::windows_core::Interface::as_raw(self), bstrgroupname.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6580,31 +6034,32 @@ impl IAzScope2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Roles)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteRole(&self, bstrrolename: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteRole)(::windows_core::Interface::as_raw(self), bstrrolename.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6612,36 +6067,38 @@ impl IAzScope2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OpenTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OpenTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtaskname: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtaskname.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } pub unsafe fn CanBeDelegated(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -6651,49 +6108,41 @@ impl IAzScope2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.BizrulesWritable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyAdministratorsName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyAdministratorsName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result { + pub unsafe fn PolicyReadersName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.PolicyReadersName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyAdministratorName(&self, bstradmin: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyAdministratorName)(::windows_core::Interface::as_raw(self), bstradmin.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddPolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddPolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeletePolicyReaderName(&self, bstrreader: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeletePolicyReaderName)(::windows_core::Interface::as_raw(self), bstrreader.into_param().abi(), varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6799,9 +6248,7 @@ pub struct IAzScope2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzScopes, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzScopes { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -6819,10 +6266,7 @@ impl IAzScopes { #[doc(hidden)] pub struct IAzScopes_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -6907,79 +6351,79 @@ impl IAzTask { { (::windows_core::Interface::vtable(self).SetIsRoleDefinition)(::windows_core::Interface::as_raw(self), fprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operations(&self) -> ::windows_core::Result { + pub unsafe fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Tasks(&self) -> ::windows_core::Result { + pub unsafe fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -7001,51 +6445,18 @@ pub struct IAzTask_Vtbl { pub SetBizRuleImportedPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprop: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsRoleDefinition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetIsRoleDefinition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fprop: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Operations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Operations: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Tasks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteOperation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteTask: usize, + pub Operations: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Tasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrop: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrtask: ::std::mem::MaybeUninit<::windows_core::BSTR>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Writable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: super::super::System::Variant::VARIANT, pvarprop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddPropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeletePropertyItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Submit: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarprop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AddPropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub DeletePropertyItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpropid: i32, varprop: ::std::mem::MaybeUninit<::windows_core::VARIANT>, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Submit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, varreserved: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7128,79 +6539,79 @@ impl IAzTask2 { { (::windows_core::Interface::vtable(self).base__.SetIsRoleDefinition)(::windows_core::Interface::as_raw(self), fprop.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Operations(&self) -> ::windows_core::Result { + pub unsafe fn Operations(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Operations)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Tasks(&self) -> ::windows_core::Result { + pub unsafe fn Tasks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Tasks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteOperation(&self, bstrop: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteOperation)(::windows_core::Interface::as_raw(self), bstrop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.AddTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn DeleteTask(&self, bstrtask: P0, varreserved: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), ::core::mem::transmute(varreserved)).ok() + (::windows_core::Interface::vtable(self).base__.DeleteTask)(::windows_core::Interface::as_raw(self), bstrtask.into_param().abi(), varreserved.into_param().abi()).ok() } pub unsafe fn Writable(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Writable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, lpropid: i32, varreserved: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varreserved), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetProperty)(::windows_core::Interface::as_raw(self), lpropid, varreserved.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn SetProperty(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetProperty)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn AddPropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.AddPropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: super::super::System::Variant::VARIANT, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, ::core::mem::transmute(varprop), ::core::mem::transmute(varreserved)).ok() + pub unsafe fn DeletePropertyItem(&self, lpropid: i32, varprop: P0, varreserved: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.DeletePropertyItem)(::windows_core::Interface::as_raw(self), lpropid, varprop.into_param().abi(), varreserved.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Submit(&self, lflags: i32, varreserved: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(varreserved)).ok() + pub unsafe fn Submit(&self, lflags: i32, varreserved: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Submit)(::windows_core::Interface::as_raw(self), lflags, varreserved.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -7234,9 +6645,7 @@ pub struct IAzTask2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAzTasks, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAzTasks { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -7254,10 +6663,7 @@ impl IAzTasks { #[doc(hidden)] pub struct IAzTasks_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvarobtptr: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumptr: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/impl.rs b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/impl.rs index 5bd7eaef00..7eba73c60b 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAlternativeName_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeFromString(&self, r#type: AlternativeNameType, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromRawData(&self, r#type: AlternativeNameType, encoding: EncodingType, strrawdata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -9,9 +9,9 @@ pub trait IAlternativeName_Impl: Sized + super::super::super::System::Com::IDisp fn ObjectId(&self) -> ::windows_core::Result; fn get_RawData(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAlternativeName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAlternativeName_Vtbl { pub const fn new, Impl: IAlternativeName_Impl, const OFFSET: isize>() -> IAlternativeName_Vtbl { unsafe extern "system" fn InitializeFromString, Impl: IAlternativeName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: AlternativeNameType, strvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -88,8 +88,8 @@ impl IAlternativeName_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAlternativeNames_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -98,9 +98,9 @@ pub trait IAlternativeNames_Impl: Sized + super::super::super::System::Com::IDis fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAlternativeNames {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAlternativeNames_Vtbl { pub const fn new, Impl: IAlternativeNames_Impl, const OFFSET: isize>() -> IAlternativeNames_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IAlternativeNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -165,16 +165,16 @@ impl IAlternativeNames_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBinaryConverter_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn StringToString(&self, strencodedin: &::windows_core::BSTR, encodingin: EncodingType, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; - fn VariantByteArrayToString(&self, pvarbytearray: *const super::super::super::System::Variant::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; - fn StringToVariantByteArray(&self, strencoded: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result; + fn VariantByteArrayToString(&self, pvarbytearray: *const ::windows_core::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; + fn StringToVariantByteArray(&self, strencoded: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBinaryConverter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBinaryConverter_Vtbl { pub const fn new, Impl: IBinaryConverter_Impl, const OFFSET: isize>() -> IBinaryConverter_Vtbl { unsafe extern "system" fn StringToString, Impl: IBinaryConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodedin: ::std::mem::MaybeUninit<::windows_core::BSTR>, encodingin: EncodingType, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -188,7 +188,7 @@ impl IBinaryConverter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn VariantByteArrayToString, Impl: IBinaryConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbytearray: *const super::super::super::System::Variant::VARIANT, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn VariantByteArrayToString, Impl: IBinaryConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbytearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.VariantByteArrayToString(::core::mem::transmute_copy(&pvarbytearray), ::core::mem::transmute_copy(&encoding)) { @@ -199,7 +199,7 @@ impl IBinaryConverter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn StringToVariantByteArray, Impl: IBinaryConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencoded: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, pvarbytearray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StringToVariantByteArray, Impl: IBinaryConverter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencoded: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, pvarbytearray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StringToVariantByteArray(::core::mem::transmute(&strencoded), ::core::mem::transmute_copy(&encoding)) { @@ -221,18 +221,18 @@ impl IBinaryConverter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBinaryConverter2_Impl: Sized + IBinaryConverter_Impl { - fn StringArrayToVariantArray(&self, pvarstringarray: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn VariantArrayToStringArray(&self, pvarvariantarray: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn StringArrayToVariantArray(&self, pvarstringarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn VariantArrayToStringArray(&self, pvarvariantarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBinaryConverter2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBinaryConverter2_Vtbl { pub const fn new, Impl: IBinaryConverter2_Impl, const OFFSET: isize>() -> IBinaryConverter2_Vtbl { - unsafe extern "system" fn StringArrayToVariantArray, Impl: IBinaryConverter2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarstringarray: *const super::super::super::System::Variant::VARIANT, pvarvariantarray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StringArrayToVariantArray, Impl: IBinaryConverter2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarstringarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvariantarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StringArrayToVariantArray(::core::mem::transmute_copy(&pvarstringarray)) { @@ -243,7 +243,7 @@ impl IBinaryConverter2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn VariantArrayToStringArray, Impl: IBinaryConverter2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvariantarray: *const super::super::super::System::Variant::VARIANT, pvarstringarray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn VariantArrayToStringArray, Impl: IBinaryConverter2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvariantarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarstringarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.VariantArrayToStringArray(::core::mem::transmute_copy(&pvarvariantarray)) { @@ -264,8 +264,8 @@ impl IBinaryConverter2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICEnroll_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn createFilePKCS10(&self, dnname: &::windows_core::BSTR, usage: &::windows_core::BSTR, wszpkcs10filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn acceptFilePKCS7(&self, wszpkcs7filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -324,9 +324,9 @@ pub trait ICEnroll_Impl: Sized + super::super::super::System::Com::IDispatch_Imp fn HashAlgorithm(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHashAlgorithm(&self, bstr: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICEnroll {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICEnroll_Vtbl { pub const fn new, Impl: ICEnroll_Impl, const OFFSET: isize>() -> ICEnroll_Vtbl { unsafe extern "system" fn createFilePKCS10, Impl: ICEnroll_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dnname: ::std::mem::MaybeUninit<::windows_core::BSTR>, usage: ::std::mem::MaybeUninit<::windows_core::BSTR>, wszpkcs10filename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -841,8 +841,8 @@ impl ICEnroll_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICEnroll2_Impl: Sized + ICEnroll_Impl { fn addCertTypeToRequest(&self, certtype: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn addNameValuePairToSignature(&self, name: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -851,9 +851,9 @@ pub trait ICEnroll2_Impl: Sized + ICEnroll_Impl { fn EnableT61DNEncoding(&self) -> ::windows_core::Result; fn SetEnableT61DNEncoding(&self, fbool: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICEnroll2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICEnroll2_Vtbl { pub const fn new, Impl: ICEnroll2_Impl, const OFFSET: isize>() -> ICEnroll2_Vtbl { unsafe extern "system" fn addCertTypeToRequest, Impl: ICEnroll2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, certtype: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -912,8 +912,8 @@ impl ICEnroll2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICEnroll3_Impl: Sized + ICEnroll2_Impl { fn InstallPKCS7(&self, pkcs7: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; @@ -930,9 +930,9 @@ pub trait ICEnroll3_Impl: Sized + ICEnroll2_Impl { fn SetEnableSMIMECapabilities(&self, fenablesmimecapabilities: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn EnableSMIMECapabilities(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICEnroll3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICEnroll3_Vtbl { pub const fn new, Impl: ICEnroll3_Impl, const OFFSET: isize>() -> ICEnroll3_Vtbl { unsafe extern "system" fn InstallPKCS7, Impl: ICEnroll3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkcs7: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1075,8 +1075,8 @@ impl ICEnroll3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICEnroll4_Impl: Sized + ICEnroll3_Impl { fn SetPrivateKeyArchiveCertificate(&self, bstrcert: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PrivateKeyArchiveCertificate(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1098,7 +1098,7 @@ pub trait ICEnroll4_Impl: Sized + ICEnroll3_Impl { fn createPFX(&self, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn createFilePFX(&self, strpassword: &::windows_core::BSTR, strpfxfilename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn setPendingRequestInfo(&self, lrequestid: i32, strcadns: &::windows_core::BSTR, strcaname: &::windows_core::BSTR, strfriendlyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn enumPendingRequest(&self, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY) -> ::windows_core::Result; + fn enumPendingRequest(&self, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY) -> ::windows_core::Result<::windows_core::VARIANT>; fn removePendingRequest(&self, strthumbprint: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetKeyLenEx(&self, lsizespec: XEKL_KEYSIZE, lkeyspec: XEKL_KEYSPEC) -> ::windows_core::Result; fn InstallPKCS7Ex(&self, pkcs7: &::windows_core::BSTR) -> ::windows_core::Result; @@ -1112,9 +1112,9 @@ pub trait ICEnroll4_Impl: Sized + ICEnroll3_Impl { fn SetIncludeSubjectKeyID(&self, finclude: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn IncludeSubjectKeyID(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICEnroll4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICEnroll4_Vtbl { pub const fn new, Impl: ICEnroll4_Impl, const OFFSET: isize>() -> ICEnroll4_Vtbl { unsafe extern "system" fn SetPrivateKeyArchiveCertificate, Impl: ICEnroll4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcert: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1265,7 +1265,7 @@ impl ICEnroll4_Vtbl { let this = (*this).get_impl(); this.setPendingRequestInfo(::core::mem::transmute_copy(&lrequestid), ::core::mem::transmute(&strcadns), ::core::mem::transmute(&strcaname), ::core::mem::transmute(&strfriendlyname)).into() } - unsafe extern "system" fn enumPendingRequest, Impl: ICEnroll4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY, pvarproperty: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn enumPendingRequest, Impl: ICEnroll4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.enumPendingRequest(::core::mem::transmute_copy(&lindex), ::core::mem::transmute_copy(&ldesiredproperty)) { @@ -1407,23 +1407,23 @@ impl ICEnroll4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertAdmin_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn IsValidCertificate(&self, strconfig: &::windows_core::BSTR, strserialnumber: &::windows_core::BSTR) -> ::windows_core::Result; fn GetRevocationReason(&self) -> ::windows_core::Result; fn RevokeCertificate(&self, strconfig: &::windows_core::BSTR, strserialnumber: &::windows_core::BSTR, reason: i32, date: f64) -> ::windows_core::Result<()>; fn SetRequestAttributes(&self, strconfig: &::windows_core::BSTR, requestid: i32, strattributes: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetCertificateExtension(&self, strconfig: &::windows_core::BSTR, requestid: i32, strextensionname: &::windows_core::BSTR, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetCertificateExtension(&self, strconfig: &::windows_core::BSTR, requestid: i32, strextensionname: &::windows_core::BSTR, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DenyRequest(&self, strconfig: &::windows_core::BSTR, requestid: i32) -> ::windows_core::Result<()>; fn ResubmitRequest(&self, strconfig: &::windows_core::BSTR, requestid: i32) -> ::windows_core::Result; fn PublishCRL(&self, strconfig: &::windows_core::BSTR, date: f64) -> ::windows_core::Result<()>; fn GetCRL(&self, strconfig: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn ImportCertificate(&self, strconfig: &::windows_core::BSTR, strcertificate: &::windows_core::BSTR, flags: CERT_IMPORT_FLAGS) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertAdmin {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertAdmin_Vtbl { pub const fn new, Impl: ICertAdmin_Impl, const OFFSET: isize>() -> ICertAdmin_Vtbl { unsafe extern "system" fn IsValidCertificate, Impl: ICertAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strserialnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdisposition: *mut i32) -> ::windows_core::HRESULT { @@ -1458,7 +1458,7 @@ impl ICertAdmin_Vtbl { let this = (*this).get_impl(); this.SetRequestAttributes(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&requestid), ::core::mem::transmute(&strattributes)).into() } - unsafe extern "system" fn SetCertificateExtension, Impl: ICertAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCertificateExtension, Impl: ICertAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCertificateExtension(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&requestid), ::core::mem::transmute(&strextensionname), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -1524,24 +1524,24 @@ impl ICertAdmin_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertAdmin2_Impl: Sized + ICertAdmin_Impl { fn PublishCRLs(&self, strconfig: &::windows_core::BSTR, date: f64, crlflags: i32) -> ::windows_core::Result<()>; - fn GetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result; - fn SetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetCAPropertyFlags(&self, strconfig: &::windows_core::BSTR, propid: i32) -> ::windows_core::Result; fn GetCAPropertyDisplayName(&self, strconfig: &::windows_core::BSTR, propid: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn GetArchivedKey(&self, strconfig: &::windows_core::BSTR, requestid: i32, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetConfigEntry(&self, strconfig: &::windows_core::BSTR, strnodepath: &::windows_core::BSTR, strentryname: &::windows_core::BSTR) -> ::windows_core::Result; - fn SetConfigEntry(&self, strconfig: &::windows_core::BSTR, strnodepath: &::windows_core::BSTR, strentryname: &::windows_core::BSTR, pvarentry: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetConfigEntry(&self, strconfig: &::windows_core::BSTR, strnodepath: &::windows_core::BSTR, strentryname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetConfigEntry(&self, strconfig: &::windows_core::BSTR, strnodepath: &::windows_core::BSTR, strentryname: &::windows_core::BSTR, pvarentry: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ImportKey(&self, strconfig: &::windows_core::BSTR, requestid: i32, strcerthash: &::windows_core::BSTR, flags: CERT_IMPORT_FLAGS, strkey: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetMyRoles(&self, strconfig: &::windows_core::BSTR) -> ::windows_core::Result; fn DeleteRow(&self, strconfig: &::windows_core::BSTR, flags: CERT_DELETE_ROW_FLAGS, date: f64, table: CVRC_TABLE, rowid: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertAdmin2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertAdmin2_Vtbl { pub const fn new, Impl: ICertAdmin2_Impl, const OFFSET: isize>() -> ICertAdmin2_Vtbl { unsafe extern "system" fn PublishCRLs, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, date: f64, crlflags: i32) -> ::windows_core::HRESULT { @@ -1549,7 +1549,7 @@ impl ICertAdmin2_Vtbl { let this = (*this).get_impl(); this.PublishCRLs(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&date), ::core::mem::transmute_copy(&crlflags)).into() } - unsafe extern "system" fn GetCAProperty, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCAProperty, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCAProperty(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&propid), ::core::mem::transmute_copy(&propindex), ::core::mem::transmute_copy(&proptype), ::core::mem::transmute_copy(&flags)) { @@ -1560,7 +1560,7 @@ impl ICertAdmin2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCAProperty, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCAProperty, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCAProperty(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&propid), ::core::mem::transmute_copy(&propindex), ::core::mem::transmute_copy(&proptype), ::core::mem::transmute_copy(&pvarpropertyvalue)).into() @@ -1598,7 +1598,7 @@ impl ICertAdmin2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetConfigEntry, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetConfigEntry, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetConfigEntry(::core::mem::transmute(&strconfig), ::core::mem::transmute(&strnodepath), ::core::mem::transmute(&strentryname)) { @@ -1609,7 +1609,7 @@ impl ICertAdmin2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetConfigEntry, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetConfigEntry, Impl: ICertAdmin2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetConfigEntry(::core::mem::transmute(&strconfig), ::core::mem::transmute(&strnodepath), ::core::mem::transmute(&strentryname), ::core::mem::transmute_copy(&pvarentry)).into() @@ -1660,17 +1660,17 @@ impl ICertAdmin2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertConfig_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Reset(&self, index: i32) -> ::windows_core::Result; fn Next(&self) -> ::windows_core::Result; fn GetField(&self, strfieldname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn GetConfig(&self, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertConfig {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertConfig_Vtbl { pub const fn new, Impl: ICertConfig_Impl, const OFFSET: isize>() -> ICertConfig_Vtbl { unsafe extern "system" fn Reset, Impl: ICertConfig_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -1729,14 +1729,14 @@ impl ICertConfig_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertConfig2_Impl: Sized + ICertConfig_Impl { fn SetSharedFolder(&self, strsharedfolder: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertConfig2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertConfig2_Vtbl { pub const fn new, Impl: ICertConfig2_Impl, const OFFSET: isize>() -> ICertConfig2_Vtbl { unsafe extern "system" fn SetSharedFolder, Impl: ICertConfig2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strsharedfolder: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1750,8 +1750,8 @@ impl ICertConfig2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeAltName_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetNameCount(&self) -> ::windows_core::Result; @@ -1761,9 +1761,9 @@ pub trait ICertEncodeAltName_Impl: Sized + super::super::super::System::Com::IDi fn SetNameEntry(&self, nameindex: i32, namechoice: CERT_ALT_NAME, strname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeAltName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeAltName_Vtbl { pub const fn new, Impl: ICertEncodeAltName_Impl, const OFFSET: isize>() -> ICertEncodeAltName_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeAltName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1840,17 +1840,17 @@ impl ICertEncodeAltName_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeAltName2_Impl: Sized + ICertEncodeAltName_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn GetNameBlob(&self, nameindex: i32, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn SetNameEntryBlob(&self, nameindex: i32, namechoice: i32, strname: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeAltName2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeAltName2_Vtbl { pub const fn new, Impl: ICertEncodeAltName2_Impl, const OFFSET: isize>() -> ICertEncodeAltName2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeAltName2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -1897,17 +1897,17 @@ impl ICertEncodeAltName2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeBitString_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetBitCount(&self) -> ::windows_core::Result; fn GetBitString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Encode(&self, bitcount: i32, strbitstring: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeBitString {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeBitString_Vtbl { pub const fn new, Impl: ICertEncodeBitString_Impl, const OFFSET: isize>() -> ICertEncodeBitString_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeBitString_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1960,16 +1960,16 @@ impl ICertEncodeBitString_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeBitString2_Impl: Sized + ICertEncodeBitString_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, bitcount: i32, strbitstring: &::windows_core::BSTR, encodingin: EncodingType, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn GetBitStringBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeBitString2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeBitString2_Vtbl { pub const fn new, Impl: ICertEncodeBitString2_Impl, const OFFSET: isize>() -> ICertEncodeBitString2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeBitString2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -2010,8 +2010,8 @@ impl ICertEncodeBitString2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeCRLDistInfo_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetDistPointCount(&self) -> ::windows_core::Result; @@ -2023,9 +2023,9 @@ pub trait ICertEncodeCRLDistInfo_Impl: Sized + super::super::super::System::Com: fn SetNameEntry(&self, distpointindex: i32, nameindex: i32, namechoice: CERT_ALT_NAME, strname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeCRLDistInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeCRLDistInfo_Vtbl { pub const fn new, Impl: ICertEncodeCRLDistInfo_Impl, const OFFSET: isize>() -> ICertEncodeCRLDistInfo_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeCRLDistInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2120,15 +2120,15 @@ impl ICertEncodeCRLDistInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeCRLDistInfo2_Impl: Sized + ICertEncodeCRLDistInfo_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeCRLDistInfo2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeCRLDistInfo2_Vtbl { pub const fn new, Impl: ICertEncodeCRLDistInfo2_Impl, const OFFSET: isize>() -> ICertEncodeCRLDistInfo2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeCRLDistInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -2157,8 +2157,8 @@ impl ICertEncodeCRLDistInfo2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeDateArray_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetCount(&self) -> ::windows_core::Result; @@ -2167,9 +2167,9 @@ pub trait ICertEncodeDateArray_Impl: Sized + super::super::super::System::Com::I fn SetValue(&self, index: i32, value: f64) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeDateArray {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeDateArray_Vtbl { pub const fn new, Impl: ICertEncodeDateArray_Impl, const OFFSET: isize>() -> ICertEncodeDateArray_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeDateArray_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2234,15 +2234,15 @@ impl ICertEncodeDateArray_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeDateArray2_Impl: Sized + ICertEncodeDateArray_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeDateArray2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeDateArray2_Vtbl { pub const fn new, Impl: ICertEncodeDateArray2_Impl, const OFFSET: isize>() -> ICertEncodeDateArray2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeDateArray2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -2271,8 +2271,8 @@ impl ICertEncodeDateArray2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeLongArray_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetCount(&self) -> ::windows_core::Result; @@ -2281,9 +2281,9 @@ pub trait ICertEncodeLongArray_Impl: Sized + super::super::super::System::Com::I fn SetValue(&self, index: i32, value: i32) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeLongArray {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeLongArray_Vtbl { pub const fn new, Impl: ICertEncodeLongArray_Impl, const OFFSET: isize>() -> ICertEncodeLongArray_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeLongArray_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2348,15 +2348,15 @@ impl ICertEncodeLongArray_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeLongArray2_Impl: Sized + ICertEncodeLongArray_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeLongArray2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeLongArray2_Vtbl { pub const fn new, Impl: ICertEncodeLongArray2_Impl, const OFFSET: isize>() -> ICertEncodeLongArray2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeLongArray2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -2385,8 +2385,8 @@ impl ICertEncodeLongArray2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeStringArray_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strbinary: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetStringType(&self) -> ::windows_core::Result; @@ -2396,9 +2396,9 @@ pub trait ICertEncodeStringArray_Impl: Sized + super::super::super::System::Com: fn SetValue(&self, index: i32, str: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeStringArray {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeStringArray_Vtbl { pub const fn new, Impl: ICertEncodeStringArray_Impl, const OFFSET: isize>() -> ICertEncodeStringArray_Vtbl { unsafe extern "system" fn Decode, Impl: ICertEncodeStringArray_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strbinary: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2475,15 +2475,15 @@ impl ICertEncodeStringArray_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertEncodeStringArray2_Impl: Sized + ICertEncodeStringArray_Impl { fn DecodeBlob(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn EncodeBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertEncodeStringArray2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertEncodeStringArray2_Vtbl { pub const fn new, Impl: ICertEncodeStringArray2_Impl, const OFFSET: isize>() -> ICertEncodeStringArray2_Vtbl { unsafe extern "system" fn DecodeBlob, Impl: ICertEncodeStringArray2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -2512,16 +2512,16 @@ impl ICertEncodeStringArray2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertExit_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, strconfig: &::windows_core::BSTR) -> ::windows_core::Result; fn Notify(&self, exitevent: i32, context: i32) -> ::windows_core::Result<()>; fn GetDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertExit {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertExit_Vtbl { pub const fn new, Impl: ICertExit_Impl, const OFFSET: isize>() -> ICertExit_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, peventmask: *mut CERT_EXIT_EVENT_MASK) -> ::windows_core::HRESULT { @@ -2562,14 +2562,14 @@ impl ICertExit_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertExit2_Impl: Sized + ICertExit_Impl { fn GetManageModule(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertExit2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertExit2_Vtbl { pub const fn new, Impl: ICertExit2_Impl, const OFFSET: isize>() -> ICertExit2_Vtbl { unsafe extern "system" fn GetManageModule, Impl: ICertExit2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmanagemodule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2589,14 +2589,14 @@ impl ICertExit2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertGetConfig_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetConfig(&self, flags: CERT_GET_CONFIG_FLAGS) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertGetConfig {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertGetConfig_Vtbl { pub const fn new, Impl: ICertGetConfig_Impl, const OFFSET: isize>() -> ICertGetConfig_Vtbl { unsafe extern "system" fn GetConfig, Impl: ICertGetConfig_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: CERT_GET_CONFIG_FLAGS, pstrout: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2616,19 +2616,19 @@ impl ICertGetConfig_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertManageModule_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn GetProperty(&self, strconfig: &::windows_core::BSTR, strstoragelocation: &::windows_core::BSTR, strpropertyname: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result; - fn SetProperty(&self, strconfig: &::windows_core::BSTR, strstoragelocation: &::windows_core::BSTR, strpropertyname: &::windows_core::BSTR, flags: i32, pvarproperty: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, strconfig: &::windows_core::BSTR, strstoragelocation: &::windows_core::BSTR, strpropertyname: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, strconfig: &::windows_core::BSTR, strstoragelocation: &::windows_core::BSTR, strpropertyname: &::windows_core::BSTR, flags: i32, pvarproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Configure(&self, strconfig: &::windows_core::BSTR, strstoragelocation: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertManageModule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertManageModule_Vtbl { pub const fn new, Impl: ICertManageModule_Impl, const OFFSET: isize>() -> ICertManageModule_Vtbl { - unsafe extern "system" fn GetProperty, Impl: ICertManageModule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ICertManageModule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&strconfig), ::core::mem::transmute(&strstoragelocation), ::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&flags)) { @@ -2639,7 +2639,7 @@ impl ICertManageModule_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: ICertManageModule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: ICertManageModule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&strconfig), ::core::mem::transmute(&strstoragelocation), ::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&pvarproperty)).into() @@ -2660,17 +2660,17 @@ impl ICertManageModule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPolicy_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, strconfig: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn VerifyRequest(&self, strconfig: &::windows_core::BSTR, context: i32, bnewrequest: i32, flags: i32) -> ::windows_core::Result; fn GetDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ShutDown(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPolicy_Vtbl { pub const fn new, Impl: ICertPolicy_Impl, const OFFSET: isize>() -> ICertPolicy_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2717,14 +2717,14 @@ impl ICertPolicy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPolicy2_Impl: Sized + ICertPolicy_Impl { fn GetManageModule(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPolicy2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPolicy2_Vtbl { pub const fn new, Impl: ICertPolicy2_Impl, const OFFSET: isize>() -> ICertPolicy2_Vtbl { unsafe extern "system" fn GetManageModule, Impl: ICertPolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppmanagemodule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2744,8 +2744,8 @@ impl ICertPolicy2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertProperties_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -2755,9 +2755,9 @@ pub trait ICertProperties_Impl: Sized + super::super::super::System::Com::IDispa fn Clear(&self) -> ::windows_core::Result<()>; fn InitializeFromCertificate(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertProperties_Vtbl { pub const fn new, Impl: ICertProperties_Impl, const OFFSET: isize>() -> ICertProperties_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICertProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2828,8 +2828,8 @@ impl ICertProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertProperty_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeFromCertificate(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2839,9 +2839,9 @@ pub trait ICertProperty_Impl: Sized + super::super::super::System::Com::IDispatc fn RemoveFromCertificate(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetValueOnCertificate(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertProperty_Vtbl { pub const fn new, Impl: ICertProperty_Impl, const OFFSET: isize>() -> ICertProperty_Vtbl { unsafe extern "system" fn InitializeFromCertificate, Impl: ICertProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2906,15 +2906,15 @@ impl ICertProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyArchived_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, archivedvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Archived(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyArchived {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyArchived_Vtbl { pub const fn new, Impl: ICertPropertyArchived_Impl, const OFFSET: isize>() -> ICertPropertyArchived_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyArchived_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, archivedvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2943,15 +2943,15 @@ impl ICertPropertyArchived_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyArchivedKeyHash_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, encoding: EncodingType, strarchivedkeyhashvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_ArchivedKeyHash(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyArchivedKeyHash {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyArchivedKeyHash_Vtbl { pub const fn new, Impl: ICertPropertyArchivedKeyHash_Impl, const OFFSET: isize>() -> ICertPropertyArchivedKeyHash_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyArchivedKeyHash_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strarchivedkeyhashvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2980,15 +2980,15 @@ impl ICertPropertyArchivedKeyHash_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyAutoEnroll_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TemplateName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyAutoEnroll {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyAutoEnroll_Vtbl { pub const fn new, Impl: ICertPropertyAutoEnroll_Impl, const OFFSET: isize>() -> ICertPropertyAutoEnroll_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyAutoEnroll_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strtemplatename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3017,17 +3017,17 @@ impl ICertPropertyAutoEnroll_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyBackedUp_Impl: Sized + ICertProperty_Impl { fn InitializeFromCurrentTime(&self, backedupvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Initialize(&self, backedupvalue: super::super::super::Foundation::VARIANT_BOOL, date: f64) -> ::windows_core::Result<()>; fn BackedUpValue(&self) -> ::windows_core::Result; fn BackedUpTime(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyBackedUp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyBackedUp_Vtbl { pub const fn new, Impl: ICertPropertyBackedUp_Impl, const OFFSET: isize>() -> ICertPropertyBackedUp_Vtbl { unsafe extern "system" fn InitializeFromCurrentTime, Impl: ICertPropertyBackedUp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, backedupvalue: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3074,15 +3074,15 @@ impl ICertPropertyBackedUp_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyDescription_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, strdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyDescription {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyDescription_Vtbl { pub const fn new, Impl: ICertPropertyDescription_Impl, const OFFSET: isize>() -> ICertPropertyDescription_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3111,8 +3111,8 @@ impl ICertPropertyDescription_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyEnrollment_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, requestid: i32, strcadnsname: &::windows_core::BSTR, strcaname: &::windows_core::BSTR, strfriendlyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RequestId(&self) -> ::windows_core::Result; @@ -3120,9 +3120,9 @@ pub trait ICertPropertyEnrollment_Impl: Sized + ICertProperty_Impl { fn CAName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FriendlyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyEnrollment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyEnrollment_Vtbl { pub const fn new, Impl: ICertPropertyEnrollment_Impl, const OFFSET: isize>() -> ICertPropertyEnrollment_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyEnrollment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, requestid: i32, strcadnsname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strcaname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3187,8 +3187,8 @@ impl ICertPropertyEnrollment_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyEnrollmentPolicyServer_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, propertyflags: EnrollmentPolicyServerPropertyFlags, authflags: X509EnrollmentAuthFlags, enrollmentserverauthflags: X509EnrollmentAuthFlags, urlflags: PolicyServerUrlFlags, strrequestid: &::windows_core::BSTR, strurl: &::windows_core::BSTR, strid: &::windows_core::BSTR, strenrollmentserverurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetPolicyServerUrl(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3200,9 +3200,9 @@ pub trait ICertPropertyEnrollmentPolicyServer_Impl: Sized + ICertProperty_Impl { fn GetAuthentication(&self) -> ::windows_core::Result; fn GetEnrollmentServerAuthentication(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyEnrollmentPolicyServer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyEnrollmentPolicyServer_Vtbl { pub const fn new, Impl: ICertPropertyEnrollmentPolicyServer_Impl, const OFFSET: isize>() -> ICertPropertyEnrollmentPolicyServer_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyEnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyflags: EnrollmentPolicyServerPropertyFlags, authflags: X509EnrollmentAuthFlags, enrollmentserverauthflags: X509EnrollmentAuthFlags, urlflags: PolicyServerUrlFlags, strrequestid: ::std::mem::MaybeUninit<::windows_core::BSTR>, strurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, strid: ::std::mem::MaybeUninit<::windows_core::BSTR>, strenrollmentserverurl: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3315,15 +3315,15 @@ impl ICertPropertyEnrollmentPolicyServer_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyFriendlyName_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, strfriendlyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FriendlyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyFriendlyName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyFriendlyName_Vtbl { pub const fn new, Impl: ICertPropertyFriendlyName_Impl, const OFFSET: isize>() -> ICertPropertyFriendlyName_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyFriendlyName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3352,15 +3352,15 @@ impl ICertPropertyFriendlyName_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyKeyProvInfo_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, pvalue: ::core::option::Option<&IX509PrivateKey>) -> ::windows_core::Result<()>; fn PrivateKey(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyKeyProvInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyKeyProvInfo_Vtbl { pub const fn new, Impl: ICertPropertyKeyProvInfo_Impl, const OFFSET: isize>() -> ICertPropertyKeyProvInfo_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyKeyProvInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3389,16 +3389,16 @@ impl ICertPropertyKeyProvInfo_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyRenewal_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, encoding: EncodingType, strrenewalvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromCertificateHash(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_Renewal(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyRenewal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyRenewal_Vtbl { pub const fn new, Impl: ICertPropertyRenewal_Impl, const OFFSET: isize>() -> ICertPropertyRenewal_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyRenewal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strrenewalvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3433,16 +3433,16 @@ impl ICertPropertyRenewal_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertyRequestOriginator_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, strrequestoriginator: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromLocalRequestOriginator(&self) -> ::windows_core::Result<()>; fn RequestOriginator(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertyRequestOriginator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertyRequestOriginator_Vtbl { pub const fn new, Impl: ICertPropertyRequestOriginator_Impl, const OFFSET: isize>() -> ICertPropertyRequestOriginator_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertyRequestOriginator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strrequestoriginator: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3477,15 +3477,15 @@ impl ICertPropertyRequestOriginator_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertPropertySHA1Hash_Impl: Sized + ICertProperty_Impl { fn Initialize(&self, encoding: EncodingType, strrenewalvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_SHA1Hash(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertPropertySHA1Hash {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertPropertySHA1Hash_Vtbl { pub const fn new, Impl: ICertPropertySHA1Hash_Impl, const OFFSET: isize>() -> ICertPropertySHA1Hash_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertPropertySHA1Hash_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strrenewalvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3514,8 +3514,8 @@ impl ICertPropertySHA1Hash_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertRequest_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Submit(&self, flags: i32, strrequest: &::windows_core::BSTR, strattributes: &::windows_core::BSTR, strconfig: &::windows_core::BSTR) -> ::windows_core::Result; fn RetrievePending(&self, requestid: i32, strconfig: &::windows_core::BSTR) -> ::windows_core::Result; @@ -3525,9 +3525,9 @@ pub trait ICertRequest_Impl: Sized + super::super::super::System::Com::IDispatch fn GetCACertificate(&self, fexchangecertificate: i32, strconfig: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn GetCertificate(&self, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertRequest_Vtbl { pub const fn new, Impl: ICertRequest_Impl, const OFFSET: isize>() -> ICertRequest_Vtbl { unsafe extern "system" fn Submit, Impl: ICertRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: i32, strrequest: ::std::mem::MaybeUninit<::windows_core::BSTR>, strattributes: ::std::mem::MaybeUninit<::windows_core::BSTR>, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdisposition: *mut i32) -> ::windows_core::HRESULT { @@ -3622,19 +3622,19 @@ impl ICertRequest_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertRequest2_Impl: Sized + ICertRequest_Impl { fn GetIssuedCertificate(&self, strconfig: &::windows_core::BSTR, requestid: i32, strserialnumber: &::windows_core::BSTR) -> ::windows_core::Result; fn GetErrorMessageText(&self, hrmessage: i32, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result; + fn GetCAProperty(&self, strconfig: &::windows_core::BSTR, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetCAPropertyFlags(&self, strconfig: &::windows_core::BSTR, propid: i32) -> ::windows_core::Result; fn GetCAPropertyDisplayName(&self, strconfig: &::windows_core::BSTR, propid: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result; + fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertRequest2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertRequest2_Vtbl { pub const fn new, Impl: ICertRequest2_Impl, const OFFSET: isize>() -> ICertRequest2_Vtbl { unsafe extern "system" fn GetIssuedCertificate, Impl: ICertRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strserialnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdisposition: *mut CR_DISP) -> ::windows_core::HRESULT { @@ -3659,7 +3659,7 @@ impl ICertRequest2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCAProperty, Impl: ICertRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCAProperty, Impl: ICertRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCAProperty(::core::mem::transmute(&strconfig), ::core::mem::transmute_copy(&propid), ::core::mem::transmute_copy(&propindex), ::core::mem::transmute_copy(&proptype), ::core::mem::transmute_copy(&flags)) { @@ -3692,7 +3692,7 @@ impl ICertRequest2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetFullResponseProperty, Impl: ICertRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFullResponseProperty, Impl: ICertRequest2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFullResponseProperty(::core::mem::transmute_copy(&propid), ::core::mem::transmute_copy(&propindex), ::core::mem::transmute_copy(&proptype), ::core::mem::transmute_copy(&flags)) { @@ -3717,17 +3717,17 @@ impl ICertRequest2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertRequest3_Impl: Sized + ICertRequest2_Impl { fn SetCredential(&self, hwnd: i32, authtype: X509EnrollmentAuthFlags, strcredential: &::windows_core::BSTR, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetRequestIdString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetIssuedCertificate2(&self, strconfig: &::windows_core::BSTR, strrequestid: &::windows_core::BSTR, strserialnumber: &::windows_core::BSTR) -> ::windows_core::Result; fn GetRefreshPolicy(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertRequest3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertRequest3_Vtbl { pub const fn new, Impl: ICertRequest3_Impl, const OFFSET: isize>() -> ICertRequest3_Vtbl { unsafe extern "system" fn SetCredential, Impl: ICertRequest3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: i32, authtype: X509EnrollmentAuthFlags, strcredential: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3867,14 +3867,14 @@ impl ICertRequestD2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertServerExit_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn SetContext(&self, context: i32) -> ::windows_core::Result<()>; - fn GetRequestProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result; + fn GetRequestProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetRequestAttribute(&self, strattributename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result; - fn GetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: i32) -> ::windows_core::Result; + fn GetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetCertificateExtensionFlags(&self) -> ::windows_core::Result; fn EnumerateExtensionsSetup(&self, flags: i32) -> ::windows_core::Result<()>; fn EnumerateExtensions(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3883,9 +3883,9 @@ pub trait ICertServerExit_Impl: Sized + super::super::super::System::Com::IDispa fn EnumerateAttributes(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EnumerateAttributesClose(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertServerExit {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertServerExit_Vtbl { pub const fn new, Impl: ICertServerExit_Impl, const OFFSET: isize>() -> ICertServerExit_Vtbl { unsafe extern "system" fn SetContext, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: i32) -> ::windows_core::HRESULT { @@ -3893,7 +3893,7 @@ impl ICertServerExit_Vtbl { let this = (*this).get_impl(); this.SetContext(::core::mem::transmute_copy(&context)).into() } - unsafe extern "system" fn GetRequestProperty, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRequestProperty, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRequestProperty(::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&propertytype)) { @@ -3915,7 +3915,7 @@ impl ICertServerExit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCertificateProperty, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCertificateProperty, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCertificateProperty(::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&propertytype)) { @@ -3926,7 +3926,7 @@ impl ICertServerExit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCertificateExtension, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCertificateExtension, Impl: ICertServerExit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCertificateExtension(::core::mem::transmute(&strextensionname), ::core::mem::transmute_copy(&r#type)) { @@ -4010,17 +4010,17 @@ impl ICertServerExit_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertServerPolicy_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn SetContext(&self, context: i32) -> ::windows_core::Result<()>; - fn GetRequestProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result; + fn GetRequestProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetRequestAttribute(&self, strattributename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: CERT_PROPERTY_TYPE) -> ::windows_core::Result; - fn SetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: CERT_PROPERTY_TYPE) -> ::windows_core::Result; + fn GetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: CERT_PROPERTY_TYPE) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCertificateProperty(&self, strpropertyname: &::windows_core::BSTR, propertytype: i32, pvarpropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: CERT_PROPERTY_TYPE) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetCertificateExtensionFlags(&self) -> ::windows_core::Result; - fn SetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: i32, extflags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetCertificateExtension(&self, strextensionname: &::windows_core::BSTR, r#type: i32, extflags: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EnumerateExtensionsSetup(&self, flags: i32) -> ::windows_core::Result<()>; fn EnumerateExtensions(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EnumerateExtensionsClose(&self) -> ::windows_core::Result<()>; @@ -4028,9 +4028,9 @@ pub trait ICertServerPolicy_Impl: Sized + super::super::super::System::Com::IDis fn EnumerateAttributes(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EnumerateAttributesClose(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertServerPolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertServerPolicy_Vtbl { pub const fn new, Impl: ICertServerPolicy_Impl, const OFFSET: isize>() -> ICertServerPolicy_Vtbl { unsafe extern "system" fn SetContext, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: i32) -> ::windows_core::HRESULT { @@ -4038,7 +4038,7 @@ impl ICertServerPolicy_Vtbl { let this = (*this).get_impl(); this.SetContext(::core::mem::transmute_copy(&context)).into() } - unsafe extern "system" fn GetRequestProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRequestProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRequestProperty(::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&propertytype)) { @@ -4060,7 +4060,7 @@ impl ICertServerPolicy_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCertificateProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCertificateProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCertificateProperty(::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&propertytype)) { @@ -4071,12 +4071,12 @@ impl ICertServerPolicy_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCertificateProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCertificateProperty, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCertificateProperty(::core::mem::transmute(&strpropertyname), ::core::mem::transmute_copy(&propertytype), ::core::mem::transmute_copy(&pvarpropertyvalue)).into() } - unsafe extern "system" fn GetCertificateExtension, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCertificateExtension, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCertificateExtension(::core::mem::transmute(&strextensionname), ::core::mem::transmute_copy(&r#type)) { @@ -4098,7 +4098,7 @@ impl ICertServerPolicy_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCertificateExtension, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, extflags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCertificateExtension, Impl: ICertServerPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, extflags: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCertificateExtension(::core::mem::transmute(&strextensionname), ::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&extflags), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -4167,8 +4167,8 @@ impl ICertServerPolicy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertView_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn OpenConnection(&self, strconfig: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn EnumCertViewColumn(&self, fresultcolumn: CVRC_COLUMN) -> ::windows_core::Result; @@ -4176,12 +4176,12 @@ pub trait ICertView_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn GetColumnIndex(&self, fresultcolumn: CVRC_COLUMN, strcolumnname: &::windows_core::BSTR, pcolumnindex: *mut i32) -> ::windows_core::Result<()>; fn SetResultColumnCount(&self, cresultcolumn: i32) -> ::windows_core::Result<()>; fn SetResultColumn(&self, columnindex: i32) -> ::windows_core::Result<()>; - fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn OpenView(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertView {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertView_Vtbl { pub const fn new, Impl: ICertView_Impl, const OFFSET: isize>() -> ICertView_Vtbl { unsafe extern "system" fn OpenConnection, Impl: ICertView_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4220,7 +4220,7 @@ impl ICertView_Vtbl { let this = (*this).get_impl(); this.SetResultColumn(::core::mem::transmute_copy(&columnindex)).into() } - unsafe extern "system" fn SetRestriction, Impl: ICertView_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetRestriction, Impl: ICertView_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetRestriction(::core::mem::transmute_copy(&columnindex), ::core::mem::transmute_copy(&seekoperator), ::core::mem::transmute_copy(&sortorder), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -4252,14 +4252,14 @@ impl ICertView_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertView2_Impl: Sized + ICertView_Impl { fn SetTable(&self, table: CVRC_TABLE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertView2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertView2_Vtbl { pub const fn new, Impl: ICertView2_Impl, const OFFSET: isize>() -> ICertView2_Vtbl { unsafe extern "system" fn SetTable, Impl: ICertView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, table: CVRC_TABLE) -> ::windows_core::HRESULT { @@ -4273,16 +4273,16 @@ impl ICertView2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificateAttestationChallenge_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, encoding: EncodingType, strpendingfullcmcresponsewithchallenge: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DecryptChallenge(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn RequestID(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificateAttestationChallenge {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificateAttestationChallenge_Vtbl { pub const fn new, Impl: ICertificateAttestationChallenge_Impl, const OFFSET: isize>() -> ICertificateAttestationChallenge_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertificateAttestationChallenge_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strpendingfullcmcresponsewithchallenge: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4323,15 +4323,15 @@ impl ICertificateAttestationChallenge_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificateAttestationChallenge2_Impl: Sized + ICertificateAttestationChallenge_Impl { fn SetKeyContainerName(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn put_KeyBlob(&self, encoding: EncodingType, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificateAttestationChallenge2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificateAttestationChallenge2_Vtbl { pub const fn new, Impl: ICertificateAttestationChallenge2_Impl, const OFFSET: isize>() -> ICertificateAttestationChallenge2_Vtbl { unsafe extern "system" fn SetKeyContainerName, Impl: ICertificateAttestationChallenge2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4354,8 +4354,8 @@ impl ICertificateAttestationChallenge2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificatePolicies_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -4364,9 +4364,9 @@ pub trait ICertificatePolicies_Impl: Sized + super::super::super::System::Com::I fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificatePolicies {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificatePolicies_Vtbl { pub const fn new, Impl: ICertificatePolicies_Impl, const OFFSET: isize>() -> ICertificatePolicies_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICertificatePolicies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4431,16 +4431,16 @@ impl ICertificatePolicies_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificatePolicy_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pvalue: ::core::option::Option<&IObjectId>) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; fn PolicyQualifiers(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificatePolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificatePolicy_Vtbl { pub const fn new, Impl: ICertificatePolicy_Impl, const OFFSET: isize>() -> ICertificatePolicy_Vtbl { unsafe extern "system" fn Initialize, Impl: ICertificatePolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4481,8 +4481,8 @@ impl ICertificatePolicy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificationAuthorities_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -4493,9 +4493,9 @@ pub trait ICertificationAuthorities_Impl: Sized + super::super::super::System::C fn ComputeSiteCosts(&self) -> ::windows_core::Result<()>; fn get_ItemByName(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificationAuthorities {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificationAuthorities_Vtbl { pub const fn new, Impl: ICertificationAuthorities_Impl, const OFFSET: isize>() -> ICertificationAuthorities_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICertificationAuthorities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4578,17 +4578,17 @@ impl ICertificationAuthorities_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificationAuthority_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn get_Property(&self, property: EnrollmentCAProperty) -> ::windows_core::Result; + fn get_Property(&self, property: EnrollmentCAProperty) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificationAuthority {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificationAuthority_Vtbl { pub const fn new, Impl: ICertificationAuthority_Impl, const OFFSET: isize>() -> ICertificationAuthority_Vtbl { - unsafe extern "system" fn get_Property, Impl: ICertificationAuthority_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentCAProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Property, Impl: ICertificationAuthority_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentCAProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Property(::core::mem::transmute_copy(&property)) { @@ -4605,17 +4605,17 @@ impl ICertificationAuthority_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICryptAttribute_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeFromObjectId(&self, pobjectid: ::core::option::Option<&IObjectId>) -> ::windows_core::Result<()>; fn InitializeFromValues(&self, pattributes: ::core::option::Option<&IX509Attributes>) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; fn Values(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICryptAttribute {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICryptAttribute_Vtbl { pub const fn new, Impl: ICryptAttribute_Impl, const OFFSET: isize>() -> ICryptAttribute_Vtbl { unsafe extern "system" fn InitializeFromObjectId, Impl: ICryptAttribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjectid: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4662,8 +4662,8 @@ impl ICryptAttribute_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICryptAttributes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -4674,9 +4674,9 @@ pub trait ICryptAttributes_Impl: Sized + super::super::super::System::Com::IDisp fn get_IndexByObjectId(&self, pobjectid: ::core::option::Option<&IObjectId>) -> ::windows_core::Result; fn AddRange(&self, pvalue: ::core::option::Option<&ICryptAttributes>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICryptAttributes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICryptAttributes_Vtbl { pub const fn new, Impl: ICryptAttributes_Impl, const OFFSET: isize>() -> ICryptAttributes_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICryptAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4759,8 +4759,8 @@ impl ICryptAttributes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspAlgorithm_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetAlgorithmOid(&self, length: i32, algflags: AlgorithmFlags) -> ::windows_core::Result; fn DefaultLength(&self) -> ::windows_core::Result; @@ -4773,9 +4773,9 @@ pub trait ICspAlgorithm_Impl: Sized + super::super::super::System::Com::IDispatc fn Type(&self) -> ::windows_core::Result; fn Operations(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspAlgorithm {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspAlgorithm_Vtbl { pub const fn new, Impl: ICspAlgorithm_Impl, const OFFSET: isize>() -> ICspAlgorithm_Vtbl { unsafe extern "system" fn GetAlgorithmOid, Impl: ICspAlgorithm_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, length: i32, algflags: AlgorithmFlags, ppvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4906,8 +4906,8 @@ impl ICspAlgorithm_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspAlgorithms_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -4918,9 +4918,9 @@ pub trait ICspAlgorithms_Impl: Sized + super::super::super::System::Com::IDispat fn get_ItemByName(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result; fn get_IndexByObjectId(&self, pobjectid: ::core::option::Option<&IObjectId>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspAlgorithms {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspAlgorithms_Vtbl { pub const fn new, Impl: ICspAlgorithms_Impl, const OFFSET: isize>() -> ICspAlgorithms_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICspAlgorithms_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5009,8 +5009,8 @@ impl ICspAlgorithms_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspInformation_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeFromName(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromType(&self, r#type: X509ProviderType, palgorithm: ::core::option::Option<&IObjectId>, machinecontext: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -5030,9 +5030,9 @@ pub trait ICspInformation_Impl: Sized + super::super::super::System::Com::IDispa fn LegacyCsp(&self) -> ::windows_core::Result; fn GetCspStatusFromOperations(&self, palgorithm: ::core::option::Option<&IObjectId>, operations: AlgorithmOperationFlags) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspInformation_Vtbl { pub const fn new, Impl: ICspInformation_Impl, const OFFSET: isize>() -> ICspInformation_Vtbl { unsafe extern "system" fn InitializeFromName, Impl: ICspInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5235,8 +5235,8 @@ impl ICspInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspInformations_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -5251,9 +5251,9 @@ pub trait ICspInformations_Impl: Sized + super::super::super::System::Com::IDisp fn GetEncryptionCspAlgorithms(&self, pcspinformation: ::core::option::Option<&ICspInformation>) -> ::windows_core::Result; fn GetHashAlgorithms(&self, pcspinformation: ::core::option::Option<&ICspInformation>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspInformations {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspInformations_Vtbl { pub const fn new, Impl: ICspInformations_Impl, const OFFSET: isize>() -> ICspInformations_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICspInformations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5384,8 +5384,8 @@ impl ICspInformations_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspStatus_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pcsp: ::core::option::Option<&ICspInformation>, palgorithm: ::core::option::Option<&ICspAlgorithm>) -> ::windows_core::Result<()>; fn Ordinal(&self) -> ::windows_core::Result; @@ -5395,9 +5395,9 @@ pub trait ICspStatus_Impl: Sized + super::super::super::System::Com::IDispatch_I fn EnrollmentStatus(&self) -> ::windows_core::Result; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspStatus_Vtbl { pub const fn new, Impl: ICspStatus_Impl, const OFFSET: isize>() -> ICspStatus_Vtbl { unsafe extern "system" fn Initialize, Impl: ICspStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcsp: *mut ::core::ffi::c_void, palgorithm: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5480,8 +5480,8 @@ impl ICspStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICspStatuses_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -5494,9 +5494,9 @@ pub trait ICspStatuses_Impl: Sized + super::super::super::System::Com::IDispatch fn get_ItemByOperations(&self, strcspname: &::windows_core::BSTR, stralgorithmname: &::windows_core::BSTR, operations: AlgorithmOperationFlags) -> ::windows_core::Result; fn get_ItemByProvider(&self, pcspstatus: ::core::option::Option<&ICspStatus>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICspStatuses {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICspStatuses_Vtbl { pub const fn new, Impl: ICspStatuses_Impl, const OFFSET: isize>() -> ICspStatuses_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ICspStatuses_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6488,8 +6488,8 @@ impl IEnroll4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEnumCERTVIEWATTRIBUTE_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Next(&self, pindex: *mut i32) -> ::windows_core::Result<()>; fn GetName(&self, pstrout: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -6498,9 +6498,9 @@ pub trait IEnumCERTVIEWATTRIBUTE_Impl: Sized + super::super::super::System::Com: fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEnumCERTVIEWATTRIBUTE {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEnumCERTVIEWATTRIBUTE_Vtbl { pub const fn new, Impl: IEnumCERTVIEWATTRIBUTE_Impl, const OFFSET: isize>() -> IEnumCERTVIEWATTRIBUTE_Vtbl { unsafe extern "system" fn Next, Impl: IEnumCERTVIEWATTRIBUTE_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pindex: *mut i32) -> ::windows_core::HRESULT { @@ -6553,8 +6553,8 @@ impl IEnumCERTVIEWATTRIBUTE_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEnumCERTVIEWCOLUMN_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Next(&self, pindex: *mut i32) -> ::windows_core::Result<()>; fn GetName(&self, pstrout: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -6562,14 +6562,14 @@ pub trait IEnumCERTVIEWCOLUMN_Impl: Sized + super::super::super::System::Com::ID fn GetType(&self, ptype: *mut i32) -> ::windows_core::Result<()>; fn IsIndexed(&self, pindexed: *mut i32) -> ::windows_core::Result<()>; fn GetMaxLength(&self, pmaxlength: *mut i32) -> ::windows_core::Result<()>; - fn GetValue(&self, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Skip(&self, celt: i32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEnumCERTVIEWCOLUMN {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEnumCERTVIEWCOLUMN_Vtbl { pub const fn new, Impl: IEnumCERTVIEWCOLUMN_Impl, const OFFSET: isize>() -> IEnumCERTVIEWCOLUMN_Vtbl { unsafe extern "system" fn Next, Impl: IEnumCERTVIEWCOLUMN_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pindex: *mut i32) -> ::windows_core::HRESULT { @@ -6602,7 +6602,7 @@ impl IEnumCERTVIEWCOLUMN_Vtbl { let this = (*this).get_impl(); this.GetMaxLength(::core::mem::transmute_copy(&pmaxlength)).into() } - unsafe extern "system" fn GetValue, Impl: IEnumCERTVIEWCOLUMN_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IEnumCERTVIEWCOLUMN_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValue(::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -6646,20 +6646,20 @@ impl IEnumCERTVIEWCOLUMN_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEnumCERTVIEWEXTENSION_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Next(&self, pindex: *mut i32) -> ::windows_core::Result<()>; fn GetName(&self, pstrout: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetFlags(&self, pflags: *mut i32) -> ::windows_core::Result<()>; - fn GetValue(&self, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Skip(&self, celt: i32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEnumCERTVIEWEXTENSION {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEnumCERTVIEWEXTENSION_Vtbl { pub const fn new, Impl: IEnumCERTVIEWEXTENSION_Impl, const OFFSET: isize>() -> IEnumCERTVIEWEXTENSION_Vtbl { unsafe extern "system" fn Next, Impl: IEnumCERTVIEWEXTENSION_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pindex: *mut i32) -> ::windows_core::HRESULT { @@ -6677,7 +6677,7 @@ impl IEnumCERTVIEWEXTENSION_Vtbl { let this = (*this).get_impl(); this.GetFlags(::core::mem::transmute_copy(&pflags)).into() } - unsafe extern "system" fn GetValue, Impl: IEnumCERTVIEWEXTENSION_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IEnumCERTVIEWEXTENSION_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValue(::core::mem::transmute_copy(&r#type), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -6718,8 +6718,8 @@ impl IEnumCERTVIEWEXTENSION_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEnumCERTVIEWROW_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Next(&self, pindex: *mut i32) -> ::windows_core::Result<()>; fn EnumCertViewColumn(&self) -> ::windows_core::Result; @@ -6730,9 +6730,9 @@ pub trait IEnumCERTVIEWROW_Impl: Sized + super::super::super::System::Com::IDisp fn Clone(&self) -> ::windows_core::Result; fn GetMaxIndex(&self, pindex: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEnumCERTVIEWROW {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEnumCERTVIEWROW_Vtbl { pub const fn new, Impl: IEnumCERTVIEWROW_Impl, const OFFSET: isize>() -> IEnumCERTVIEWROW_Vtbl { unsafe extern "system" fn Next, Impl: IEnumCERTVIEWROW_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pindex: *mut i32) -> ::windows_core::HRESULT { @@ -6869,8 +6869,8 @@ impl INDESPolicy_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IOCSPAdmin_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn OCSPServiceProperties(&self) -> ::windows_core::Result; fn OCSPCAConfigurationCollection(&self) -> ::windows_core::Result; @@ -6880,12 +6880,12 @@ pub trait IOCSPAdmin_Impl: Sized + super::super::super::System::Com::IDispatch_I fn Ping(&self, bstrservername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSecurity(&self, bstrservername: &::windows_core::BSTR, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetSecurity(&self, bstrservername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetSigningCertificates(&self, bstrservername: &::windows_core::BSTR, pcacertvar: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn GetHashAlgorithms(&self, bstrservername: &::windows_core::BSTR, bstrcaid: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetSigningCertificates(&self, bstrservername: &::windows_core::BSTR, pcacertvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetHashAlgorithms(&self, bstrservername: &::windows_core::BSTR, bstrcaid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IOCSPAdmin {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IOCSPAdmin_Vtbl { pub const fn new, Impl: IOCSPAdmin_Impl, const OFFSET: isize>() -> IOCSPAdmin_Vtbl { unsafe extern "system" fn OCSPServiceProperties, Impl: IOCSPAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6952,7 +6952,7 @@ impl IOCSPAdmin_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetSigningCertificates, Impl: IOCSPAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcacertvar: *const super::super::super::System::Variant::VARIANT, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSigningCertificates, Impl: IOCSPAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcacertvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSigningCertificates(::core::mem::transmute(&bstrservername), ::core::mem::transmute_copy(&pcacertvar)) { @@ -6963,7 +6963,7 @@ impl IOCSPAdmin_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetHashAlgorithms, Impl: IOCSPAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcaid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetHashAlgorithms, Impl: IOCSPAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcaid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetHashAlgorithms(::core::mem::transmute(&bstrservername), ::core::mem::transmute(&bstrcaid)) { @@ -6992,17 +6992,17 @@ impl IOCSPAdmin_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IOCSPCAConfiguration_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Identifier(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn CACertificate(&self) -> ::windows_core::Result; + fn CACertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn HashAlgorithm(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHashAlgorithm(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SigningFlags(&self) -> ::windows_core::Result; fn SetSigningFlags(&self, newval: u32) -> ::windows_core::Result<()>; - fn SigningCertificate(&self) -> ::windows_core::Result; - fn SetSigningCertificate(&self, newval: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SigningCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSigningCertificate(&self, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ReminderDuration(&self) -> ::windows_core::Result; fn SetReminderDuration(&self, newval: u32) -> ::windows_core::Result<()>; fn ErrorCode(&self) -> ::windows_core::Result; @@ -7010,19 +7010,19 @@ pub trait IOCSPCAConfiguration_Impl: Sized + super::super::super::System::Com::I fn KeySpec(&self) -> ::windows_core::Result; fn ProviderCLSID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetProviderCLSID(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ProviderProperties(&self) -> ::windows_core::Result; - fn SetProviderProperties(&self, newval: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ProviderProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProviderProperties(&self, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Modified(&self) -> ::windows_core::Result; - fn LocalRevocationInformation(&self) -> ::windows_core::Result; - fn SetLocalRevocationInformation(&self, newval: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn LocalRevocationInformation(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetLocalRevocationInformation(&self, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SigningCertificateTemplate(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSigningCertificateTemplate(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CAConfig(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetCAConfig(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IOCSPCAConfiguration {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IOCSPCAConfiguration_Vtbl { pub const fn new, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>() -> IOCSPCAConfiguration_Vtbl { unsafe extern "system" fn Identifier, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7036,7 +7036,7 @@ impl IOCSPCAConfiguration_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CACertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CACertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CACertificate() { @@ -7079,7 +7079,7 @@ impl IOCSPCAConfiguration_Vtbl { let this = (*this).get_impl(); this.SetSigningFlags(::core::mem::transmute_copy(&newval)).into() } - unsafe extern "system" fn SigningCertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SigningCertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SigningCertificate() { @@ -7090,7 +7090,7 @@ impl IOCSPCAConfiguration_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSigningCertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSigningCertificate, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSigningCertificate(::core::mem::transmute(&newval)).into() @@ -7160,7 +7160,7 @@ impl IOCSPCAConfiguration_Vtbl { let this = (*this).get_impl(); this.SetProviderCLSID(::core::mem::transmute(&newval)).into() } - unsafe extern "system" fn ProviderProperties, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ProviderProperties, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ProviderProperties() { @@ -7171,7 +7171,7 @@ impl IOCSPCAConfiguration_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProviderProperties, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProviderProperties, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProviderProperties(::core::mem::transmute(&newval)).into() @@ -7187,7 +7187,7 @@ impl IOCSPCAConfiguration_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LocalRevocationInformation, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LocalRevocationInformation, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LocalRevocationInformation() { @@ -7198,7 +7198,7 @@ impl IOCSPCAConfiguration_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetLocalRevocationInformation, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetLocalRevocationInformation, Impl: IOCSPCAConfiguration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetLocalRevocationInformation(::core::mem::transmute(&newval)).into() @@ -7267,19 +7267,19 @@ impl IOCSPCAConfiguration_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IOCSPCAConfigurationCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; - fn get_ItemByName(&self, bstridentifier: &::windows_core::BSTR) -> ::windows_core::Result; - fn CreateCAConfiguration(&self, bstridentifier: &::windows_core::BSTR, varcacert: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_ItemByName(&self, bstridentifier: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CreateCAConfiguration(&self, bstridentifier: &::windows_core::BSTR, varcacert: &::windows_core::VARIANT) -> ::windows_core::Result; fn DeleteCAConfiguration(&self, bstridentifier: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IOCSPCAConfigurationCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IOCSPCAConfigurationCollection_Vtbl { pub const fn new, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>() -> IOCSPCAConfigurationCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7293,7 +7293,7 @@ impl IOCSPCAConfigurationCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -7315,7 +7315,7 @@ impl IOCSPCAConfigurationCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_ItemByName, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_ItemByName, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_ItemByName(::core::mem::transmute(&bstridentifier)) { @@ -7326,7 +7326,7 @@ impl IOCSPCAConfigurationCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateCAConfiguration, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, varcacert: super::super::super::System::Variant::VARIANT, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateCAConfiguration, Impl: IOCSPCAConfigurationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, varcacert: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateCAConfiguration(::core::mem::transmute(&bstridentifier), ::core::mem::transmute(&varcacert)) { @@ -7356,17 +7356,17 @@ impl IOCSPCAConfigurationCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IOCSPProperty_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, newval: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Modified(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IOCSPProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IOCSPProperty_Vtbl { pub const fn new, Impl: IOCSPProperty_Impl, const OFFSET: isize>() -> IOCSPProperty_Vtbl { unsafe extern "system" fn Name, Impl: IOCSPProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7380,7 +7380,7 @@ impl IOCSPProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: IOCSPProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IOCSPProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -7391,7 +7391,7 @@ impl IOCSPProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IOCSPProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IOCSPProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&newval)).into() @@ -7419,21 +7419,21 @@ impl IOCSPProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IOCSPPropertyCollection_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; - fn get_ItemByName(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result; - fn CreateProperty(&self, bstrpropname: &::windows_core::BSTR, pvarpropvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn get_ItemByName(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CreateProperty(&self, bstrpropname: &::windows_core::BSTR, pvarpropvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn DeleteProperty(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn InitializeFromProperties(&self, pvarproperties: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetAllProperties(&self) -> ::windows_core::Result; + fn InitializeFromProperties(&self, pvarproperties: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetAllProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IOCSPPropertyCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IOCSPPropertyCollection_Vtbl { pub const fn new, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>() -> IOCSPPropertyCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7447,7 +7447,7 @@ impl IOCSPPropertyCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -7469,7 +7469,7 @@ impl IOCSPPropertyCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_ItemByName, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_ItemByName, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_ItemByName(::core::mem::transmute(&bstrpropname)) { @@ -7480,7 +7480,7 @@ impl IOCSPPropertyCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateProperty, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarpropvalue: *const super::super::super::System::Variant::VARIANT, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateProperty, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarpropvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateProperty(::core::mem::transmute(&bstrpropname), ::core::mem::transmute_copy(&pvarpropvalue)) { @@ -7496,12 +7496,12 @@ impl IOCSPPropertyCollection_Vtbl { let this = (*this).get_impl(); this.DeleteProperty(::core::mem::transmute(&bstrpropname)).into() } - unsafe extern "system" fn InitializeFromProperties, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarproperties: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeFromProperties, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarproperties: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InitializeFromProperties(::core::mem::transmute_copy(&pvarproperties)).into() } - unsafe extern "system" fn GetAllProperties, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarproperties: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAllProperties, Impl: IOCSPPropertyCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarproperties: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAllProperties() { @@ -7528,8 +7528,8 @@ impl IOCSPPropertyCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IObjectId_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeFromName(&self, name: CERTENROLL_OBJECTID) -> ::windows_core::Result<()>; fn InitializeFromValue(&self, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -7540,9 +7540,9 @@ pub trait IObjectId_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetAlgorithmName(&self, groupid: ObjectIdGroupId, keyflags: ObjectIdPublicKeyFlags) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IObjectId {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IObjectId_Vtbl { pub const fn new, Impl: IObjectId_Impl, const OFFSET: isize>() -> IObjectId_Vtbl { unsafe extern "system" fn InitializeFromName, Impl: IObjectId_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: CERTENROLL_OBJECTID) -> ::windows_core::HRESULT { @@ -7625,8 +7625,8 @@ impl IObjectId_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IObjectIds_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -7636,9 +7636,9 @@ pub trait IObjectIds_Impl: Sized + super::super::super::System::Com::IDispatch_I fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, pvalue: ::core::option::Option<&IObjectIds>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IObjectIds {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IObjectIds_Vtbl { pub const fn new, Impl: IObjectIds_Impl, const OFFSET: isize>() -> IObjectIds_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IObjectIds_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7709,8 +7709,8 @@ impl IObjectIds_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPolicyQualifier_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn InitializeEncode(&self, strqualifier: &::windows_core::BSTR, r#type: PolicyQualifierType) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; @@ -7718,9 +7718,9 @@ pub trait IPolicyQualifier_Impl: Sized + super::super::super::System::Com::IDisp fn Type(&self) -> ::windows_core::Result; fn get_RawData(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPolicyQualifier {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPolicyQualifier_Vtbl { pub const fn new, Impl: IPolicyQualifier_Impl, const OFFSET: isize>() -> IPolicyQualifier_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IPolicyQualifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strqualifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: PolicyQualifierType) -> ::windows_core::HRESULT { @@ -7785,8 +7785,8 @@ impl IPolicyQualifier_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPolicyQualifiers_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -7795,9 +7795,9 @@ pub trait IPolicyQualifiers_Impl: Sized + super::super::super::System::Com::IDis fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPolicyQualifiers {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPolicyQualifiers_Vtbl { pub const fn new, Impl: IPolicyQualifiers_Impl, const OFFSET: isize>() -> IPolicyQualifiers_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IPolicyQualifiers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7862,8 +7862,8 @@ impl IPolicyQualifiers_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISignerCertificate_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL, verifytype: X509PrivateKeyVerify, encoding: EncodingType, strcertificate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_Certificate(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; @@ -7877,9 +7877,9 @@ pub trait ISignerCertificate_Impl: Sized + super::super::super::System::Com::IDi fn SetPin(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SignatureInformation(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISignerCertificate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISignerCertificate_Vtbl { pub const fn new, Impl: ISignerCertificate_Impl, const OFFSET: isize>() -> ISignerCertificate_Vtbl { unsafe extern "system" fn Initialize, Impl: ISignerCertificate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, machinecontext: super::super::super::Foundation::VARIANT_BOOL, verifytype: X509PrivateKeyVerify, encoding: EncodingType, strcertificate: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -7992,8 +7992,8 @@ impl ISignerCertificate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISignerCertificates_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -8003,9 +8003,9 @@ pub trait ISignerCertificates_Impl: Sized + super::super::super::System::Com::ID fn Clear(&self) -> ::windows_core::Result<()>; fn Find(&self, psignercert: ::core::option::Option<&ISignerCertificate>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISignerCertificates {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISignerCertificates_Vtbl { pub const fn new, Impl: ISignerCertificates_Impl, const OFFSET: isize>() -> ISignerCertificates_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ISignerCertificates_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8082,8 +8082,8 @@ impl ISignerCertificates_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISmimeCapabilities_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -8094,9 +8094,9 @@ pub trait ISmimeCapabilities_Impl: Sized + super::super::super::System::Com::IDi fn AddFromCsp(&self, pvalue: ::core::option::Option<&ICspInformation>) -> ::windows_core::Result<()>; fn AddAvailableSmimeCapabilities(&self, machinecontext: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISmimeCapabilities {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISmimeCapabilities_Vtbl { pub const fn new, Impl: ISmimeCapabilities_Impl, const OFFSET: isize>() -> ISmimeCapabilities_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: ISmimeCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8173,16 +8173,16 @@ impl ISmimeCapabilities_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISmimeCapability_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pobjectid: ::core::option::Option<&IObjectId>, bitcount: i32) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; fn BitCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISmimeCapability {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISmimeCapability_Vtbl { pub const fn new, Impl: ISmimeCapability_Impl, const OFFSET: isize>() -> ISmimeCapability_Vtbl { unsafe extern "system" fn Initialize, Impl: ISmimeCapability_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjectid: *mut ::core::ffi::c_void, bitcount: i32) -> ::windows_core::HRESULT { @@ -8223,17 +8223,17 @@ impl ISmimeCapability_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX500DistinguishedName_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Decode(&self, strencodedname: &::windows_core::BSTR, encoding: EncodingType, nameflags: X500NameFlags) -> ::windows_core::Result<()>; fn Encode(&self, strname: &::windows_core::BSTR, nameflags: X500NameFlags) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn get_EncodedName(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX500DistinguishedName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX500DistinguishedName_Vtbl { pub const fn new, Impl: IX500DistinguishedName_Impl, const OFFSET: isize>() -> IX500DistinguishedName_Vtbl { unsafe extern "system" fn Decode, Impl: IX500DistinguishedName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strencodedname: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, nameflags: X500NameFlags) -> ::windows_core::HRESULT { @@ -8280,16 +8280,16 @@ impl IX500DistinguishedName_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Attribute_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pobjectid: ::core::option::Option<&IObjectId>, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; fn get_RawData(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Attribute {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Attribute_Vtbl { pub const fn new, Impl: IX509Attribute_Impl, const OFFSET: isize>() -> IX509Attribute_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509Attribute_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjectid: *mut ::core::ffi::c_void, encoding: EncodingType, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8330,8 +8330,8 @@ impl IX509Attribute_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeArchiveKey_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, pkey: ::core::option::Option<&IX509PrivateKey>, encoding: EncodingType, strcaxcert: &::windows_core::BSTR, palgorithm: ::core::option::Option<&IObjectId>, encryptionstrength: i32) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -8339,9 +8339,9 @@ pub trait IX509AttributeArchiveKey_Impl: Sized + IX509Attribute_Impl { fn EncryptionAlgorithm(&self) -> ::windows_core::Result; fn EncryptionStrength(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeArchiveKey {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeArchiveKey_Vtbl { pub const fn new, Impl: IX509AttributeArchiveKey_Impl, const OFFSET: isize>() -> IX509AttributeArchiveKey_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeArchiveKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *mut ::core::ffi::c_void, encoding: EncodingType, strcaxcert: ::std::mem::MaybeUninit<::windows_core::BSTR>, palgorithm: *mut ::core::ffi::c_void, encryptionstrength: i32) -> ::windows_core::HRESULT { @@ -8400,16 +8400,16 @@ impl IX509AttributeArchiveKey_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeArchiveKeyHash_Impl: Sized + IX509Attribute_Impl { fn InitializeEncodeFromEncryptedKeyBlob(&self, encoding: EncodingType, strencryptedkeyblob: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_EncryptedKeyHashBlob(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeArchiveKeyHash {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeArchiveKeyHash_Vtbl { pub const fn new, Impl: IX509AttributeArchiveKeyHash_Impl, const OFFSET: isize>() -> IX509AttributeArchiveKeyHash_Vtbl { unsafe extern "system" fn InitializeEncodeFromEncryptedKeyBlob, Impl: IX509AttributeArchiveKeyHash_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strencryptedkeyblob: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8444,8 +8444,8 @@ impl IX509AttributeArchiveKeyHash_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeClientId_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, clientid: RequestClientInfoClientId, strmachinednsname: &::windows_core::BSTR, strusersamname: &::windows_core::BSTR, strprocessname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -8454,9 +8454,9 @@ pub trait IX509AttributeClientId_Impl: Sized + IX509Attribute_Impl { fn UserSamName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ProcessName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeClientId {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeClientId_Vtbl { pub const fn new, Impl: IX509AttributeClientId_Impl, const OFFSET: isize>() -> IX509AttributeClientId_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeClientId_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, clientid: RequestClientInfoClientId, strmachinednsname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strusersamname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strprocessname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8527,8 +8527,8 @@ impl IX509AttributeClientId_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeCspProvider_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, keyspec: X509KeySpec, strprovidername: &::windows_core::BSTR, encoding: EncodingType, strsignature: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -8536,9 +8536,9 @@ pub trait IX509AttributeCspProvider_Impl: Sized + IX509Attribute_Impl { fn ProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn get_Signature(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeCspProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeCspProvider_Vtbl { pub const fn new, Impl: IX509AttributeCspProvider_Impl, const OFFSET: isize>() -> IX509AttributeCspProvider_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeCspProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, keyspec: X509KeySpec, strprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, strsignature: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8597,16 +8597,16 @@ impl IX509AttributeCspProvider_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeExtensions_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, pextensions: ::core::option::Option<&IX509Extensions>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn X509Extensions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeExtensions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeExtensions_Vtbl { pub const fn new, Impl: IX509AttributeExtensions_Impl, const OFFSET: isize>() -> IX509AttributeExtensions_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeExtensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pextensions: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8641,16 +8641,16 @@ impl IX509AttributeExtensions_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeOSVersion_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, strosversion: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn OSVersion(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeOSVersion {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeOSVersion_Vtbl { pub const fn new, Impl: IX509AttributeOSVersion_Impl, const OFFSET: isize>() -> IX509AttributeOSVersion_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeOSVersion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strosversion: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8685,16 +8685,16 @@ impl IX509AttributeOSVersion_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509AttributeRenewalCertificate_Impl: Sized + IX509Attribute_Impl { fn InitializeEncode(&self, encoding: EncodingType, strcert: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_RenewalCertificate(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509AttributeRenewalCertificate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509AttributeRenewalCertificate_Vtbl { pub const fn new, Impl: IX509AttributeRenewalCertificate_Impl, const OFFSET: isize>() -> IX509AttributeRenewalCertificate_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509AttributeRenewalCertificate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strcert: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -8729,8 +8729,8 @@ impl IX509AttributeRenewalCertificate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Attributes_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -8739,9 +8739,9 @@ pub trait IX509Attributes_Impl: Sized + super::super::super::System::Com::IDispa fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Attributes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Attributes_Vtbl { pub const fn new, Impl: IX509Attributes_Impl, const OFFSET: isize>() -> IX509Attributes_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509Attributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8806,8 +8806,8 @@ impl IX509Attributes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequest_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; fn Encode(&self) -> ::windows_core::Result<()>; @@ -8835,9 +8835,9 @@ pub trait IX509CertificateRequest_Impl: Sized + super::super::super::System::Com fn SetAlternateSignatureAlgorithm(&self, value: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn get_RawData(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequest {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequest_Vtbl { pub const fn new, Impl: IX509CertificateRequest_Impl, const OFFSET: isize>() -> IX509CertificateRequest_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509CertificateRequest_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext) -> ::windows_core::HRESULT { @@ -9076,8 +9076,8 @@ impl IX509CertificateRequest_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestCertificate_Impl: Sized + IX509CertificateRequestPkcs10_Impl { fn CheckPublicKeySignature(&self, ppublickey: ::core::option::Option<&IX509PublicKey>) -> ::windows_core::Result<()>; fn Issuer(&self) -> ::windows_core::Result; @@ -9091,9 +9091,9 @@ pub trait IX509CertificateRequestCertificate_Impl: Sized + IX509CertificateReque fn SignerCertificate(&self) -> ::windows_core::Result; fn SetSignerCertificate(&self, pvalue: ::core::option::Option<&ISignerCertificate>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestCertificate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestCertificate_Vtbl { pub const fn new, Impl: IX509CertificateRequestCertificate_Impl, const OFFSET: isize>() -> IX509CertificateRequestCertificate_Vtbl { unsafe extern "system" fn CheckPublicKeySignature, Impl: IX509CertificateRequestCertificate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppublickey: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9200,17 +9200,17 @@ impl IX509CertificateRequestCertificate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestCertificate2_Impl: Sized + IX509CertificateRequestCertificate_Impl { fn InitializeFromTemplate(&self, context: X509CertificateEnrollmentContext, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn InitializeFromPrivateKeyTemplate(&self, context: X509CertificateEnrollmentContext, pprivatekey: ::core::option::Option<&IX509PrivateKey>, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn PolicyServer(&self) -> ::windows_core::Result; fn Template(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestCertificate2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestCertificate2_Vtbl { pub const fn new, Impl: IX509CertificateRequestCertificate2_Impl, const OFFSET: isize>() -> IX509CertificateRequestCertificate2_Vtbl { unsafe extern "system" fn InitializeFromTemplate, Impl: IX509CertificateRequestCertificate2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, ppolicyserver: *mut ::core::ffi::c_void, ptemplate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9257,8 +9257,8 @@ impl IX509CertificateRequestCertificate2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestCmc_Impl: Sized + IX509CertificateRequestPkcs7_Impl { fn InitializeFromInnerRequestTemplateName(&self, pinnerrequest: ::core::option::Option<&IX509CertificateRequest>, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TemplateObjectId(&self) -> ::windows_core::Result; @@ -9284,9 +9284,9 @@ pub trait IX509CertificateRequestCmc_Impl: Sized + IX509CertificateRequestPkcs7_ fn get_EncryptedKeyHash(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn SignerCertificates(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestCmc {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestCmc_Vtbl { pub const fn new, Impl: IX509CertificateRequestCmc_Impl, const OFFSET: isize>() -> IX509CertificateRequestCmc_Vtbl { unsafe extern "system" fn InitializeFromInnerRequestTemplateName, Impl: IX509CertificateRequestCmc_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pinnerrequest: *mut ::core::ffi::c_void, strtemplatename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -9531,8 +9531,8 @@ impl IX509CertificateRequestCmc_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestCmc2_Impl: Sized + IX509CertificateRequestCmc_Impl { fn InitializeFromTemplate(&self, context: X509CertificateEnrollmentContext, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn InitializeFromInnerRequestTemplate(&self, pinnerrequest: ::core::option::Option<&IX509CertificateRequest>, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; @@ -9541,9 +9541,9 @@ pub trait IX509CertificateRequestCmc2_Impl: Sized + IX509CertificateRequestCmc_I fn CheckSignature(&self, allowedsignaturetypes: Pkcs10AllowedSignatureTypes) -> ::windows_core::Result<()>; fn CheckCertificateSignature(&self, psignercertificate: ::core::option::Option<&ISignerCertificate>, validatecertificatechain: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestCmc2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestCmc2_Vtbl { pub const fn new, Impl: IX509CertificateRequestCmc2_Impl, const OFFSET: isize>() -> IX509CertificateRequestCmc2_Vtbl { unsafe extern "system" fn InitializeFromTemplate, Impl: IX509CertificateRequestCmc2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, ppolicyserver: *mut ::core::ffi::c_void, ptemplate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9602,8 +9602,8 @@ impl IX509CertificateRequestCmc2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs10_Impl: Sized + IX509CertificateRequest_Impl { fn InitializeFromTemplateName(&self, context: X509CertificateEnrollmentContext, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromPrivateKey(&self, context: X509CertificateEnrollmentContext, pprivatekey: ::core::option::Option<&IX509PrivateKey>, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -9634,9 +9634,9 @@ pub trait IX509CertificateRequestPkcs10_Impl: Sized + IX509CertificateRequest_Im fn get_Signature(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn GetCspStatuses(&self, keyspec: X509KeySpec) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs10 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs10_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs10_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs10_Vtbl { unsafe extern "system" fn InitializeFromTemplateName, Impl: IX509CertificateRequestPkcs10_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, strtemplatename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -9929,8 +9929,8 @@ impl IX509CertificateRequestPkcs10_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs10V2_Impl: Sized + IX509CertificateRequestPkcs10_Impl { fn InitializeFromTemplate(&self, context: X509CertificateEnrollmentContext, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn InitializeFromPrivateKeyTemplate(&self, context: X509CertificateEnrollmentContext, pprivatekey: ::core::option::Option<&IX509PrivateKey>, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; @@ -9938,9 +9938,9 @@ pub trait IX509CertificateRequestPkcs10V2_Impl: Sized + IX509CertificateRequestP fn PolicyServer(&self) -> ::windows_core::Result; fn Template(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs10V2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs10V2_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs10V2_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs10V2_Vtbl { unsafe extern "system" fn InitializeFromTemplate, Impl: IX509CertificateRequestPkcs10V2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, ppolicyserver: *mut ::core::ffi::c_void, ptemplate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9993,8 +9993,8 @@ impl IX509CertificateRequestPkcs10V2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs10V3_Impl: Sized + IX509CertificateRequestPkcs10V2_Impl { fn AttestPrivateKey(&self) -> ::windows_core::Result; fn SetAttestPrivateKey(&self, value: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -10008,9 +10008,9 @@ pub trait IX509CertificateRequestPkcs10V3_Impl: Sized + IX509CertificateRequestP fn SetChallengePassword(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn NameValuePairs(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs10V3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs10V3_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs10V3_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs10V3_Vtbl { unsafe extern "system" fn AttestPrivateKey, Impl: IX509CertificateRequestPkcs10V3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -10123,17 +10123,17 @@ impl IX509CertificateRequestPkcs10V3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs10V4_Impl: Sized + IX509CertificateRequestPkcs10V3_Impl { fn ClaimType(&self) -> ::windows_core::Result; fn SetClaimType(&self, value: KeyAttestationClaimType) -> ::windows_core::Result<()>; fn AttestPrivateKeyPreferred(&self) -> ::windows_core::Result; fn SetAttestPrivateKeyPreferred(&self, value: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs10V4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs10V4_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs10V4_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs10V4_Vtbl { unsafe extern "system" fn ClaimType, Impl: IX509CertificateRequestPkcs10V4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut KeyAttestationClaimType) -> ::windows_core::HRESULT { @@ -10180,8 +10180,8 @@ impl IX509CertificateRequestPkcs10V4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs7_Impl: Sized + IX509CertificateRequest_Impl { fn InitializeFromTemplateName(&self, context: X509CertificateEnrollmentContext, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeFromCertificate(&self, context: X509CertificateEnrollmentContext, renewalrequest: super::super::super::Foundation::VARIANT_BOOL, strcertificate: &::windows_core::BSTR, encoding: EncodingType, inheritoptions: X509RequestInheritOptions) -> ::windows_core::Result<()>; @@ -10192,9 +10192,9 @@ pub trait IX509CertificateRequestPkcs7_Impl: Sized + IX509CertificateRequest_Imp fn SignerCertificate(&self) -> ::windows_core::Result; fn SetSignerCertificate(&self, pvalue: ::core::option::Option<&ISignerCertificate>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs7 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs7_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs7_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs7_Vtbl { unsafe extern "system" fn InitializeFromTemplateName, Impl: IX509CertificateRequestPkcs7_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, strtemplatename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -10265,17 +10265,17 @@ impl IX509CertificateRequestPkcs7_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRequestPkcs7V2_Impl: Sized + IX509CertificateRequestPkcs7_Impl { fn InitializeFromTemplate(&self, context: X509CertificateEnrollmentContext, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn PolicyServer(&self) -> ::windows_core::Result; fn Template(&self) -> ::windows_core::Result; fn CheckCertificateSignature(&self, validatecertificatechain: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRequestPkcs7V2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRequestPkcs7V2_Vtbl { pub const fn new, Impl: IX509CertificateRequestPkcs7V2_Impl, const OFFSET: isize>() -> IX509CertificateRequestPkcs7V2_Vtbl { unsafe extern "system" fn InitializeFromTemplate, Impl: IX509CertificateRequestPkcs7V2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, ppolicyserver: *mut ::core::ffi::c_void, ptemplate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10322,8 +10322,8 @@ impl IX509CertificateRequestPkcs7V2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRevocationList_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self) -> ::windows_core::Result<()>; fn InitializeDecode(&self, strencodeddata: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; @@ -10357,9 +10357,9 @@ pub trait IX509CertificateRevocationList_Impl: Sized + super::super::super::Syst fn get_RawDataToBeSigned(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn get_Signature(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRevocationList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRevocationList_Vtbl { pub const fn new, Impl: IX509CertificateRevocationList_Impl, const OFFSET: isize>() -> IX509CertificateRevocationList_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509CertificateRevocationList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10658,8 +10658,8 @@ impl IX509CertificateRevocationList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRevocationListEntries_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -10670,9 +10670,9 @@ pub trait IX509CertificateRevocationListEntries_Impl: Sized + super::super::supe fn get_IndexBySerialNumber(&self, encoding: EncodingType, serialnumber: &::windows_core::BSTR) -> ::windows_core::Result; fn AddRange(&self, pvalue: ::core::option::Option<&IX509CertificateRevocationListEntries>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRevocationListEntries {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRevocationListEntries_Vtbl { pub const fn new, Impl: IX509CertificateRevocationListEntries_Impl, const OFFSET: isize>() -> IX509CertificateRevocationListEntries_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509CertificateRevocationListEntries_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10755,8 +10755,8 @@ impl IX509CertificateRevocationListEntries_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateRevocationListEntry_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, encoding: EncodingType, serialnumber: &::windows_core::BSTR, revocationdate: f64) -> ::windows_core::Result<()>; fn get_SerialNumber(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; @@ -10766,9 +10766,9 @@ pub trait IX509CertificateRevocationListEntry_Impl: Sized + super::super::super: fn X509Extensions(&self) -> ::windows_core::Result; fn CriticalExtensions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateRevocationListEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateRevocationListEntry_Vtbl { pub const fn new, Impl: IX509CertificateRevocationListEntry_Impl, const OFFSET: isize>() -> IX509CertificateRevocationListEntry_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509CertificateRevocationListEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, serialnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>, revocationdate: f64) -> ::windows_core::HRESULT { @@ -10851,17 +10851,17 @@ impl IX509CertificateRevocationListEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateTemplate_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { - fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result; + fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateTemplate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateTemplate_Vtbl { pub const fn new, Impl: IX509CertificateTemplate_Impl, const OFFSET: isize>() -> IX509CertificateTemplate_Vtbl { - unsafe extern "system" fn get_Property, Impl: IX509CertificateTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Property, Impl: IX509CertificateTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Property(::core::mem::transmute_copy(&property)) { @@ -10878,18 +10878,18 @@ impl IX509CertificateTemplate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateTemplateWritable_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pvalue: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn Commit(&self, commitflags: CommitTemplateFlags, strservercontext: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result; - fn put_Property(&self, property: EnrollmentTemplateProperty, value: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_Property(&self, property: EnrollmentTemplateProperty, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Template(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateTemplateWritable {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateTemplateWritable_Vtbl { pub const fn new, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>() -> IX509CertificateTemplateWritable_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10902,7 +10902,7 @@ impl IX509CertificateTemplateWritable_Vtbl { let this = (*this).get_impl(); this.Commit(::core::mem::transmute_copy(&commitflags), ::core::mem::transmute(&strservercontext)).into() } - unsafe extern "system" fn get_Property, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Property, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Property(::core::mem::transmute_copy(&property)) { @@ -10913,7 +10913,7 @@ impl IX509CertificateTemplateWritable_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Property, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Property, Impl: IX509CertificateTemplateWritable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Property(::core::mem::transmute_copy(&property), ::core::mem::transmute(&value)).into() @@ -10942,8 +10942,8 @@ impl IX509CertificateTemplateWritable_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509CertificateTemplates_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -10954,9 +10954,9 @@ pub trait IX509CertificateTemplates_Impl: Sized + super::super::super::System::C fn get_ItemByName(&self, bstrname: &::windows_core::BSTR) -> ::windows_core::Result; fn get_ItemByOid(&self, poid: ::core::option::Option<&IObjectId>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509CertificateTemplates {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509CertificateTemplates_Vtbl { pub const fn new, Impl: IX509CertificateTemplates_Impl, const OFFSET: isize>() -> IX509CertificateTemplates_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509CertificateTemplates_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -11045,8 +11045,8 @@ impl IX509CertificateTemplates_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509EndorsementKey_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn ProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetProviderName(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -11060,9 +11060,9 @@ pub trait IX509EndorsementKey_Impl: Sized + super::super::super::System::Com::ID fn Open(&self) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509EndorsementKey {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509EndorsementKey_Vtbl { pub const fn new, Impl: IX509EndorsementKey_Impl, const OFFSET: isize>() -> IX509EndorsementKey_Vtbl { unsafe extern "system" fn ProviderName, Impl: IX509EndorsementKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -11175,8 +11175,8 @@ impl IX509EndorsementKey_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Enrollment_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; fn InitializeFromTemplateName(&self, context: X509CertificateEnrollmentContext, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -11202,9 +11202,9 @@ pub trait IX509Enrollment_Impl: Sized + super::super::super::System::Com::IDispa fn RequestId(&self) -> ::windows_core::Result; fn CAConfigString(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Enrollment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Enrollment_Vtbl { pub const fn new, Impl: IX509Enrollment_Impl, const OFFSET: isize>() -> IX509Enrollment_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509Enrollment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext) -> ::windows_core::HRESULT { @@ -11437,8 +11437,8 @@ impl IX509Enrollment_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Enrollment2_Impl: Sized + IX509Enrollment_Impl { fn InitializeFromTemplate(&self, context: X509CertificateEnrollmentContext, ppolicyserver: ::core::option::Option<&IX509EnrollmentPolicyServer>, ptemplate: ::core::option::Option<&IX509CertificateTemplate>) -> ::windows_core::Result<()>; fn InstallResponse2(&self, restrictions: InstallResponseRestrictionFlags, strresponse: &::windows_core::BSTR, encoding: EncodingType, strpassword: &::windows_core::BSTR, strenrollmentpolicyserverurl: &::windows_core::BSTR, strenrollmentpolicyserverid: &::windows_core::BSTR, enrollmentpolicyserverflags: PolicyServerUrlFlags, authflags: X509EnrollmentAuthFlags) -> ::windows_core::Result<()>; @@ -11446,9 +11446,9 @@ pub trait IX509Enrollment2_Impl: Sized + IX509Enrollment_Impl { fn Template(&self) -> ::windows_core::Result; fn RequestIdString(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Enrollment2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Enrollment2_Vtbl { pub const fn new, Impl: IX509Enrollment2_Impl, const OFFSET: isize>() -> IX509Enrollment2_Vtbl { unsafe extern "system" fn InitializeFromTemplate, Impl: IX509Enrollment2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext, ppolicyserver: *mut ::core::ffi::c_void, ptemplate: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -11507,17 +11507,17 @@ impl IX509Enrollment2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509EnrollmentHelper_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn AddPolicyServer(&self, strenrollmentpolicyserveruri: &::windows_core::BSTR, strenrollmentpolicyid: &::windows_core::BSTR, enrollmentpolicyserverflags: PolicyServerUrlFlags, authflags: X509EnrollmentAuthFlags, strcredential: &::windows_core::BSTR, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddEnrollmentServer(&self, strenrollmentserveruri: &::windows_core::BSTR, authflags: X509EnrollmentAuthFlags, strcredential: &::windows_core::BSTR, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Enroll(&self, strenrollmentpolicyserveruri: &::windows_core::BSTR, strtemplatename: &::windows_core::BSTR, encoding: EncodingType, enrollflags: WebEnrollmentFlags) -> ::windows_core::Result<::windows_core::BSTR>; fn Initialize(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509EnrollmentHelper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509EnrollmentHelper_Vtbl { pub const fn new, Impl: IX509EnrollmentHelper_Impl, const OFFSET: isize>() -> IX509EnrollmentHelper_Vtbl { unsafe extern "system" fn AddPolicyServer, Impl: IX509EnrollmentHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strenrollmentpolicyserveruri: ::std::mem::MaybeUninit<::windows_core::BSTR>, strenrollmentpolicyid: ::std::mem::MaybeUninit<::windows_core::BSTR>, enrollmentpolicyserverflags: PolicyServerUrlFlags, authflags: X509EnrollmentAuthFlags, strcredential: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -11558,8 +11558,8 @@ impl IX509EnrollmentHelper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509EnrollmentPolicyServer_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, bstrpolicyserverurl: &::windows_core::BSTR, bstrpolicyserverid: &::windows_core::BSTR, authflags: X509EnrollmentAuthFlags, fisuntrusted: super::super::super::Foundation::VARIANT_BOOL, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; fn LoadPolicy(&self, option: X509EnrollmentPolicyLoadOption) -> ::windows_core::Result<()>; @@ -11581,14 +11581,14 @@ pub trait IX509EnrollmentPolicyServer_Impl: Sized + super::super::super::System: fn GetAuthFlags(&self) -> ::windows_core::Result; fn SetCredential(&self, hwndparent: i32, flag: X509EnrollmentAuthFlags, strcredential: &::windows_core::BSTR, strpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn QueryChanges(&self) -> ::windows_core::Result; - fn InitializeImport(&self, val: &super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Export(&self, exportflags: X509EnrollmentPolicyExportFlags) -> ::windows_core::Result; + fn InitializeImport(&self, val: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Export(&self, exportflags: X509EnrollmentPolicyExportFlags) -> ::windows_core::Result<::windows_core::VARIANT>; fn Cost(&self) -> ::windows_core::Result; fn SetCost(&self, value: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509EnrollmentPolicyServer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509EnrollmentPolicyServer_Vtbl { pub const fn new, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>() -> IX509EnrollmentPolicyServer_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpolicyserverurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpolicyserverid: ::std::mem::MaybeUninit<::windows_core::BSTR>, authflags: X509EnrollmentAuthFlags, fisuntrusted: super::super::super::Foundation::VARIANT_BOOL, context: X509CertificateEnrollmentContext) -> ::windows_core::HRESULT { @@ -11787,12 +11787,12 @@ impl IX509EnrollmentPolicyServer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn InitializeImport, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, val: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitializeImport, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InitializeImport(::core::mem::transmute(&val)).into() } - unsafe extern "system" fn Export, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, exportflags: X509EnrollmentPolicyExportFlags, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Export, Impl: IX509EnrollmentPolicyServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, exportflags: X509EnrollmentPolicyExportFlags, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Export(::core::mem::transmute_copy(&exportflags)) { @@ -11851,8 +11851,8 @@ impl IX509EnrollmentPolicyServer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509EnrollmentStatus_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn AppendText(&self, strtext: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Text(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -11867,9 +11867,9 @@ pub trait IX509EnrollmentStatus_Impl: Sized + super::super::super::System::Com:: fn SetError(&self, value: ::windows_core::HRESULT) -> ::windows_core::Result<()>; fn ErrorText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509EnrollmentStatus {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509EnrollmentStatus_Vtbl { pub const fn new, Impl: IX509EnrollmentStatus_Impl, const OFFSET: isize>() -> IX509EnrollmentStatus_Vtbl { unsafe extern "system" fn AppendText, Impl: IX509EnrollmentStatus_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strtext: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -11988,14 +11988,14 @@ impl IX509EnrollmentStatus_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509EnrollmentWebClassFactory_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn CreateObject(&self, strprogid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509EnrollmentWebClassFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509EnrollmentWebClassFactory_Vtbl { pub const fn new, Impl: IX509EnrollmentWebClassFactory_Impl, const OFFSET: isize>() -> IX509EnrollmentWebClassFactory_Vtbl { unsafe extern "system" fn CreateObject, Impl: IX509EnrollmentWebClassFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppiunknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12015,8 +12015,8 @@ impl IX509EnrollmentWebClassFactory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Extension_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pobjectid: ::core::option::Option<&IObjectId>, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ObjectId(&self) -> ::windows_core::Result; @@ -12024,9 +12024,9 @@ pub trait IX509Extension_Impl: Sized + super::super::super::System::Com::IDispat fn Critical(&self) -> ::windows_core::Result; fn SetCritical(&self, value: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Extension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Extension_Vtbl { pub const fn new, Impl: IX509Extension_Impl, const OFFSET: isize>() -> IX509Extension_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509Extension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjectid: *mut ::core::ffi::c_void, encoding: EncodingType, strencodeddata: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -12085,16 +12085,16 @@ impl IX509Extension_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionAlternativeNames_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, pvalue: ::core::option::Option<&IAlternativeNames>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AlternativeNames(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionAlternativeNames {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionAlternativeNames_Vtbl { pub const fn new, Impl: IX509ExtensionAlternativeNames_Impl, const OFFSET: isize>() -> IX509ExtensionAlternativeNames_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionAlternativeNames_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12129,16 +12129,16 @@ impl IX509ExtensionAlternativeNames_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionAuthorityKeyIdentifier_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, encoding: EncodingType, strkeyidentifier: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_AuthorityKeyIdentifier(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionAuthorityKeyIdentifier {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionAuthorityKeyIdentifier_Vtbl { pub const fn new, Impl: IX509ExtensionAuthorityKeyIdentifier_Impl, const OFFSET: isize>() -> IX509ExtensionAuthorityKeyIdentifier_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionAuthorityKeyIdentifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strkeyidentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -12173,17 +12173,17 @@ impl IX509ExtensionAuthorityKeyIdentifier_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionBasicConstraints_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, isca: super::super::super::Foundation::VARIANT_BOOL, pathlenconstraint: i32) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsCA(&self) -> ::windows_core::Result; fn PathLenConstraint(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionBasicConstraints {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionBasicConstraints_Vtbl { pub const fn new, Impl: IX509ExtensionBasicConstraints_Impl, const OFFSET: isize>() -> IX509ExtensionBasicConstraints_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionBasicConstraints_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, isca: super::super::super::Foundation::VARIANT_BOOL, pathlenconstraint: i32) -> ::windows_core::HRESULT { @@ -12230,16 +12230,16 @@ impl IX509ExtensionBasicConstraints_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionCertificatePolicies_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, pvalue: ::core::option::Option<&ICertificatePolicies>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Policies(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionCertificatePolicies {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionCertificatePolicies_Vtbl { pub const fn new, Impl: IX509ExtensionCertificatePolicies_Impl, const OFFSET: isize>() -> IX509ExtensionCertificatePolicies_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionCertificatePolicies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12274,16 +12274,16 @@ impl IX509ExtensionCertificatePolicies_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionEnhancedKeyUsage_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, pvalue: ::core::option::Option<&IObjectIds>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn EnhancedKeyUsage(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionEnhancedKeyUsage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionEnhancedKeyUsage_Vtbl { pub const fn new, Impl: IX509ExtensionEnhancedKeyUsage_Impl, const OFFSET: isize>() -> IX509ExtensionEnhancedKeyUsage_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionEnhancedKeyUsage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12318,16 +12318,16 @@ impl IX509ExtensionEnhancedKeyUsage_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionKeyUsage_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, usageflags: X509KeyUsageFlags) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn KeyUsage(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionKeyUsage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionKeyUsage_Vtbl { pub const fn new, Impl: IX509ExtensionKeyUsage_Impl, const OFFSET: isize>() -> IX509ExtensionKeyUsage_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionKeyUsage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, usageflags: X509KeyUsageFlags) -> ::windows_core::HRESULT { @@ -12362,16 +12362,16 @@ impl IX509ExtensionKeyUsage_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionMSApplicationPolicies_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, pvalue: ::core::option::Option<&ICertificatePolicies>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Policies(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionMSApplicationPolicies {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionMSApplicationPolicies_Vtbl { pub const fn new, Impl: IX509ExtensionMSApplicationPolicies_Impl, const OFFSET: isize>() -> IX509ExtensionMSApplicationPolicies_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionMSApplicationPolicies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12406,16 +12406,16 @@ impl IX509ExtensionMSApplicationPolicies_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionSmimeCapabilities_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, pvalue: ::core::option::Option<&ISmimeCapabilities>) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SmimeCapabilities(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionSmimeCapabilities {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionSmimeCapabilities_Vtbl { pub const fn new, Impl: IX509ExtensionSmimeCapabilities_Impl, const OFFSET: isize>() -> IX509ExtensionSmimeCapabilities_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionSmimeCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12450,16 +12450,16 @@ impl IX509ExtensionSmimeCapabilities_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionSubjectKeyIdentifier_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, encoding: EncodingType, strkeyidentifier: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn get_SubjectKeyIdentifier(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionSubjectKeyIdentifier {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionSubjectKeyIdentifier_Vtbl { pub const fn new, Impl: IX509ExtensionSubjectKeyIdentifier_Impl, const OFFSET: isize>() -> IX509ExtensionSubjectKeyIdentifier_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionSubjectKeyIdentifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, strkeyidentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -12494,8 +12494,8 @@ impl IX509ExtensionSubjectKeyIdentifier_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionTemplate_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, ptemplateoid: ::core::option::Option<&IObjectId>, majorversion: i32, minorversion: i32) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -12503,9 +12503,9 @@ pub trait IX509ExtensionTemplate_Impl: Sized + IX509Extension_Impl { fn MajorVersion(&self) -> ::windows_core::Result; fn MinorVersion(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionTemplate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionTemplate_Vtbl { pub const fn new, Impl: IX509ExtensionTemplate_Impl, const OFFSET: isize>() -> IX509ExtensionTemplate_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptemplateoid: *mut ::core::ffi::c_void, majorversion: i32, minorversion: i32) -> ::windows_core::HRESULT { @@ -12564,16 +12564,16 @@ impl IX509ExtensionTemplate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509ExtensionTemplateName_Impl: Sized + IX509Extension_Impl { fn InitializeEncode(&self, strtemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeDecode(&self, encoding: EncodingType, strencodeddata: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TemplateName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509ExtensionTemplateName {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509ExtensionTemplateName_Vtbl { pub const fn new, Impl: IX509ExtensionTemplateName_Impl, const OFFSET: isize>() -> IX509ExtensionTemplateName_Vtbl { unsafe extern "system" fn InitializeEncode, Impl: IX509ExtensionTemplateName_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strtemplatename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -12608,8 +12608,8 @@ impl IX509ExtensionTemplateName_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509Extensions_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -12620,9 +12620,9 @@ pub trait IX509Extensions_Impl: Sized + super::super::super::System::Com::IDispa fn get_IndexByObjectId(&self, pobjectid: ::core::option::Option<&IObjectId>) -> ::windows_core::Result; fn AddRange(&self, pvalue: ::core::option::Option<&IX509Extensions>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509Extensions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509Extensions_Vtbl { pub const fn new, Impl: IX509Extensions_Impl, const OFFSET: isize>() -> IX509Extensions_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509Extensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12705,14 +12705,14 @@ impl IX509Extensions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509MachineEnrollmentFactory_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn CreateObject(&self, strprogid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509MachineEnrollmentFactory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509MachineEnrollmentFactory_Vtbl { pub const fn new, Impl: IX509MachineEnrollmentFactory_Impl, const OFFSET: isize>() -> IX509MachineEnrollmentFactory_Vtbl { unsafe extern "system" fn CreateObject, Impl: IX509MachineEnrollmentFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppihelper: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12732,16 +12732,16 @@ impl IX509MachineEnrollmentFactory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509NameValuePair_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, strname: &::windows_core::BSTR, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509NameValuePair {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509NameValuePair_Vtbl { pub const fn new, Impl: IX509NameValuePair_Impl, const OFFSET: isize>() -> IX509NameValuePair_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509NameValuePair_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -12782,8 +12782,8 @@ impl IX509NameValuePair_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509NameValuePairs_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -12792,9 +12792,9 @@ pub trait IX509NameValuePairs_Impl: Sized + super::super::super::System::Com::ID fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509NameValuePairs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509NameValuePairs_Vtbl { pub const fn new, Impl: IX509NameValuePairs_Impl, const OFFSET: isize>() -> IX509NameValuePairs_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509NameValuePairs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12859,8 +12859,8 @@ impl IX509NameValuePairs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509PolicyServerListManager_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn get_ItemByIndex(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; @@ -12870,9 +12870,9 @@ pub trait IX509PolicyServerListManager_Impl: Sized + super::super::super::System fn Clear(&self) -> ::windows_core::Result<()>; fn Initialize(&self, context: X509CertificateEnrollmentContext, flags: PolicyServerUrlFlags) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509PolicyServerListManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509PolicyServerListManager_Vtbl { pub const fn new, Impl: IX509PolicyServerListManager_Impl, const OFFSET: isize>() -> IX509PolicyServerListManager_Vtbl { unsafe extern "system" fn get_ItemByIndex, Impl: IX509PolicyServerListManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -12943,8 +12943,8 @@ impl IX509PolicyServerListManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509PolicyServerUrl_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; fn Url(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -12962,9 +12962,9 @@ pub trait IX509PolicyServerUrl_Impl: Sized + super::super::super::System::Com::I fn UpdateRegistry(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; fn RemoveFromRegistry(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509PolicyServerUrl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509PolicyServerUrl_Vtbl { pub const fn new, Impl: IX509PolicyServerUrl_Impl, const OFFSET: isize>() -> IX509PolicyServerUrl_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509PolicyServerUrl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: X509CertificateEnrollmentContext) -> ::windows_core::HRESULT { @@ -13101,8 +13101,8 @@ impl IX509PolicyServerUrl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509PrivateKey_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Open(&self) -> ::windows_core::Result<()>; fn Create(&self) -> ::windows_core::Result<()>; @@ -13163,9 +13163,9 @@ pub trait IX509PrivateKey_Impl: Sized + super::super::super::System::Com::IDispa fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509PrivateKey {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509PrivateKey_Vtbl { pub const fn new, Impl: IX509PrivateKey_Impl, const OFFSET: isize>() -> IX509PrivateKey_Vtbl { unsafe extern "system" fn Open, Impl: IX509PrivateKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -13692,8 +13692,8 @@ impl IX509PrivateKey_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509PrivateKey2_Impl: Sized + IX509PrivateKey_Impl { fn HardwareKeyUsage(&self) -> ::windows_core::Result; fn SetHardwareKeyUsage(&self, value: X509HardwareKeyUsageFlags) -> ::windows_core::Result<()>; @@ -13706,9 +13706,9 @@ pub trait IX509PrivateKey2_Impl: Sized + IX509PrivateKey_Impl { fn ParametersExportType(&self) -> ::windows_core::Result; fn SetParametersExportType(&self, value: X509KeyParametersExportType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509PrivateKey2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509PrivateKey2_Vtbl { pub const fn new, Impl: IX509PrivateKey2_Impl, const OFFSET: isize>() -> IX509PrivateKey2_Vtbl { unsafe extern "system" fn HardwareKeyUsage, Impl: IX509PrivateKey2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut X509HardwareKeyUsageFlags) -> ::windows_core::HRESULT { @@ -13809,8 +13809,8 @@ impl IX509PrivateKey2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509PublicKey_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, pobjectid: ::core::option::Option<&IObjectId>, strencodedkey: &::windows_core::BSTR, strencodedparameters: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn InitializeFromEncodedPublicKeyInfo(&self, strencodedpublickeyinfo: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; @@ -13820,9 +13820,9 @@ pub trait IX509PublicKey_Impl: Sized + super::super::super::System::Com::IDispat fn get_EncodedParameters(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn ComputeKeyIdentifier(&self, algorithm: KeyIdentifierHashAlgorithm, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509PublicKey {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509PublicKey_Vtbl { pub const fn new, Impl: IX509PublicKey_Impl, const OFFSET: isize>() -> IX509PublicKey_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509PublicKey_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pobjectid: *mut ::core::ffi::c_void, strencodedkey: ::std::mem::MaybeUninit<::windows_core::BSTR>, strencodedparameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -13905,8 +13905,8 @@ impl IX509PublicKey_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509SCEPEnrollment_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, prequest: ::core::option::Option<&IX509CertificateRequestPkcs10>, strthumbprint: &::windows_core::BSTR, thumprintencoding: EncodingType, strservercertificates: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result<()>; fn InitializeForPending(&self, context: X509CertificateEnrollmentContext) -> ::windows_core::Result<()>; @@ -13931,9 +13931,9 @@ pub trait IX509SCEPEnrollment_Impl: Sized + super::super::super::System::Com::ID fn SetSilent(&self, value: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn DeleteRequest(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509SCEPEnrollment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509SCEPEnrollment_Vtbl { pub const fn new, Impl: IX509SCEPEnrollment_Impl, const OFFSET: isize>() -> IX509SCEPEnrollment_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509SCEPEnrollment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, prequest: *mut ::core::ffi::c_void, strthumbprint: ::std::mem::MaybeUninit<::windows_core::BSTR>, thumprintencoding: EncodingType, strservercertificates: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType) -> ::windows_core::HRESULT { @@ -14154,8 +14154,8 @@ impl IX509SCEPEnrollment_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509SCEPEnrollment2_Impl: Sized + IX509SCEPEnrollment_Impl { fn CreateChallengeAnswerMessage(&self, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR>; fn ProcessResponseMessage2(&self, flags: X509SCEPProcessMessageFlags, strresponse: &::windows_core::BSTR, encoding: EncodingType) -> ::windows_core::Result; @@ -14164,9 +14164,9 @@ pub trait IX509SCEPEnrollment2_Impl: Sized + IX509SCEPEnrollment_Impl { fn ActivityId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetActivityId(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509SCEPEnrollment2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509SCEPEnrollment2_Vtbl { pub const fn new, Impl: IX509SCEPEnrollment2_Impl, const OFFSET: isize>() -> IX509SCEPEnrollment2_Vtbl { unsafe extern "system" fn CreateChallengeAnswerMessage, Impl: IX509SCEPEnrollment2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, encoding: EncodingType, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14243,8 +14243,8 @@ impl IX509SCEPEnrollment2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509SCEPEnrollmentHelper_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Initialize(&self, strserverurl: &::windows_core::BSTR, strrequestheaders: &::windows_core::BSTR, prequest: ::core::option::Option<&IX509CertificateRequestPkcs10>, strcacertificatethumbprint: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InitializeForPending(&self, strserverurl: &::windows_core::BSTR, strrequestheaders: &::windows_core::BSTR, context: X509CertificateEnrollmentContext, strtransactionid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -14253,9 +14253,9 @@ pub trait IX509SCEPEnrollmentHelper_Impl: Sized + super::super::super::System::C fn X509SCEPEnrollment(&self) -> ::windows_core::Result; fn ResultMessageText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509SCEPEnrollmentHelper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509SCEPEnrollmentHelper_Vtbl { pub const fn new, Impl: IX509SCEPEnrollmentHelper_Impl, const OFFSET: isize>() -> IX509SCEPEnrollmentHelper_Vtbl { unsafe extern "system" fn Initialize, Impl: IX509SCEPEnrollmentHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strserverurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, strrequestheaders: ::std::mem::MaybeUninit<::windows_core::BSTR>, prequest: *mut ::core::ffi::c_void, strcacertificatethumbprint: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -14326,8 +14326,8 @@ impl IX509SCEPEnrollmentHelper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IX509SignatureInformation_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn HashAlgorithm(&self) -> ::windows_core::Result; fn SetHashAlgorithm(&self, pvalue: ::core::option::Option<&IObjectId>) -> ::windows_core::Result<()>; @@ -14343,9 +14343,9 @@ pub trait IX509SignatureInformation_Impl: Sized + super::super::super::System::C fn GetSignatureAlgorithm(&self, pkcs7signature: super::super::super::Foundation::VARIANT_BOOL, signaturekey: super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; fn SetDefaultValues(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IX509SignatureInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IX509SignatureInformation_Vtbl { pub const fn new, Impl: IX509SignatureInformation_Impl, const OFFSET: isize>() -> IX509SignatureInformation_Vtbl { unsafe extern "system" fn HashAlgorithm, Impl: IX509SignatureInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/mod.rs b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/mod.rs index f9c69d495b..e4c6050341 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/Certificates/mod.rs @@ -314,15 +314,11 @@ impl IBinaryConverter { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StringToString)(::windows_core::Interface::as_raw(self), strencodedin.into_param().abi(), encodingin, encoding, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantByteArrayToString(&self, pvarbytearray: *const super::super::super::System::Variant::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn VariantByteArrayToString(&self, pvarbytearray: *const ::windows_core::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).VariantByteArrayToString)(::windows_core::Interface::as_raw(self), pvarbytearray, encoding, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).VariantByteArrayToString)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarbytearray), encoding, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StringToVariantByteArray(&self, strencoded: P0, encoding: EncodingType) -> ::windows_core::Result + pub unsafe fn StringToVariantByteArray(&self, strencoded: P0, encoding: EncodingType) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -336,14 +332,8 @@ impl IBinaryConverter { pub struct IBinaryConverter_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub StringToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strencodedin: ::std::mem::MaybeUninit<::windows_core::BSTR>, encodingin: EncodingType, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VariantByteArrayToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbytearray: *const super::super::super::System::Variant::VARIANT, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VariantByteArrayToString: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StringToVariantByteArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strencoded: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, pvarbytearray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StringToVariantByteArray: usize, + pub VariantByteArrayToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbytearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, encoding: EncodingType, pstrencoded: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub StringToVariantByteArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strencoded: ::std::mem::MaybeUninit<::windows_core::BSTR>, encoding: EncodingType, pvarbytearray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -363,32 +353,24 @@ impl IBinaryConverter2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.StringToString)(::windows_core::Interface::as_raw(self), strencodedin.into_param().abi(), encodingin, encoding, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantByteArrayToString(&self, pvarbytearray: *const super::super::super::System::Variant::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn VariantByteArrayToString(&self, pvarbytearray: *const ::windows_core::VARIANT, encoding: EncodingType) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.VariantByteArrayToString)(::windows_core::Interface::as_raw(self), pvarbytearray, encoding, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.VariantByteArrayToString)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarbytearray), encoding, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StringToVariantByteArray(&self, strencoded: P0, encoding: EncodingType) -> ::windows_core::Result + pub unsafe fn StringToVariantByteArray(&self, strencoded: P0, encoding: EncodingType) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.StringToVariantByteArray)(::windows_core::Interface::as_raw(self), strencoded.into_param().abi(), encoding, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StringArrayToVariantArray(&self, pvarstringarray: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn StringArrayToVariantArray(&self, pvarstringarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).StringArrayToVariantArray)(::windows_core::Interface::as_raw(self), pvarstringarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).StringArrayToVariantArray)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarstringarray), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantArrayToStringArray(&self, pvarvariantarray: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantArrayToStringArray(&self, pvarvariantarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).VariantArrayToStringArray)(::windows_core::Interface::as_raw(self), pvarvariantarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).VariantArrayToStringArray)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvariantarray), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -396,14 +378,8 @@ impl IBinaryConverter2 { #[doc(hidden)] pub struct IBinaryConverter2_Vtbl { pub base__: IBinaryConverter_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StringArrayToVariantArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarstringarray: *const super::super::super::System::Variant::VARIANT, pvarvariantarray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StringArrayToVariantArray: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VariantArrayToStringArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvariantarray: *const super::super::super::System::Variant::VARIANT, pvarstringarray: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VariantArrayToStringArray: usize, + pub StringArrayToVariantArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarstringarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvariantarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub VariantArrayToStringArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvariantarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarstringarray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1962,9 +1938,7 @@ impl ICEnroll4 { { (::windows_core::Interface::vtable(self).setPendingRequestInfo)(::windows_core::Interface::as_raw(self), lrequestid, strcadns.into_param().abi(), strcaname.into_param().abi(), strfriendlyname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn enumPendingRequest(&self, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY) -> ::windows_core::Result { + pub unsafe fn enumPendingRequest(&self, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).enumPendingRequest)(::windows_core::Interface::as_raw(self), lindex, ldesiredproperty, &mut result__).from_abi(result__) } @@ -2057,10 +2031,7 @@ pub struct ICEnroll4_Vtbl { pub createPFX: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, pstrpfx: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub createFilePFX: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpfxfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub setPendingRequestInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lrequestid: i32, strcadns: ::std::mem::MaybeUninit<::windows_core::BSTR>, strcaname: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub enumPendingRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY, pvarproperty: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - enumPendingRequest: usize, + pub enumPendingRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, ldesiredproperty: PENDING_REQUEST_DESIRED_PROPERTY, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removePendingRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strthumbprint: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetKeyLenEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsizespec: XEKL_KEYSIZE, lkeyspec: XEKL_KEYSPEC, pdwkeysize: *mut i32) -> ::windows_core::HRESULT, pub InstallPKCS7Ex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkcs7: ::std::mem::MaybeUninit<::windows_core::BSTR>, plcertinstalled: *mut i32) -> ::windows_core::HRESULT, @@ -2111,14 +2082,12 @@ impl ICertAdmin { { (::windows_core::Interface::vtable(self).SetRequestAttributes)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strattributes.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCertificateExtension(&self, strconfig: P0, requestid: i32, strextensionname: P1, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetCertificateExtension(&self, strconfig: P0, requestid: i32, strextensionname: P1, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetCertificateExtension)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strextensionname.into_param().abi(), r#type, flags, pvarvalue).ok() + (::windows_core::Interface::vtable(self).SetCertificateExtension)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strextensionname.into_param().abi(), r#type, flags, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn DenyRequest(&self, strconfig: P0, requestid: i32) -> ::windows_core::Result<()> where @@ -2164,10 +2133,7 @@ pub struct ICertAdmin_Vtbl { pub GetRevocationReason: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, preason: *mut i32) -> ::windows_core::HRESULT, pub RevokeCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strserialnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>, reason: i32, date: f64) -> ::windows_core::HRESULT, pub SetRequestAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strattributes: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCertificateExtension: usize, + pub SetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DenyRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32) -> ::windows_core::HRESULT, pub ResubmitRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, pdisposition: *mut i32) -> ::windows_core::HRESULT, pub PublishCRL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, date: f64) -> ::windows_core::HRESULT, @@ -2211,14 +2177,12 @@ impl ICertAdmin2 { { (::windows_core::Interface::vtable(self).base__.SetRequestAttributes)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strattributes.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCertificateExtension(&self, strconfig: P0, requestid: i32, strextensionname: P1, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetCertificateExtension(&self, strconfig: P0, requestid: i32, strextensionname: P1, r#type: CERT_PROPERTY_TYPE, flags: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.SetCertificateExtension)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strextensionname.into_param().abi(), r#type, flags, pvarvalue).ok() + (::windows_core::Interface::vtable(self).base__.SetCertificateExtension)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, strextensionname.into_param().abi(), r#type, flags, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn DenyRequest(&self, strconfig: P0, requestid: i32) -> ::windows_core::Result<()> where @@ -2260,22 +2224,18 @@ impl ICertAdmin2 { { (::windows_core::Interface::vtable(self).PublishCRLs)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), date, crlflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result + pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCAProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), propid, propindex, proptype, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetCAProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), propid, propindex, proptype, pvarpropertyvalue).ok() + (::windows_core::Interface::vtable(self).SetCAProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), propid, propindex, proptype, ::core::mem::transmute(pvarpropertyvalue)).ok() } pub unsafe fn GetCAPropertyFlags(&self, strconfig: P0, propid: i32) -> ::windows_core::Result where @@ -2298,9 +2258,7 @@ impl ICertAdmin2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetArchivedKey)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), requestid, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetConfigEntry(&self, strconfig: P0, strnodepath: P1, strentryname: P2) -> ::windows_core::Result + pub unsafe fn GetConfigEntry(&self, strconfig: P0, strnodepath: P1, strentryname: P2) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -2309,15 +2267,13 @@ impl ICertAdmin2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetConfigEntry)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strnodepath.into_param().abi(), strentryname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetConfigEntry(&self, strconfig: P0, strnodepath: P1, strentryname: P2, pvarentry: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetConfigEntry(&self, strconfig: P0, strnodepath: P1, strentryname: P2, pvarentry: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetConfigEntry)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strnodepath.into_param().abi(), strentryname.into_param().abi(), pvarentry).ok() + (::windows_core::Interface::vtable(self).SetConfigEntry)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strnodepath.into_param().abi(), strentryname.into_param().abi(), ::core::mem::transmute(pvarentry)).ok() } pub unsafe fn ImportKey(&self, strconfig: P0, requestid: i32, strcerthash: P1, flags: CERT_IMPORT_FLAGS, strkey: P2) -> ::windows_core::Result<()> where @@ -2348,25 +2304,13 @@ impl ICertAdmin2 { pub struct ICertAdmin2_Vtbl { pub base__: ICertAdmin_Vtbl, pub PublishCRLs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, date: f64, crlflags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCAProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCAProperty: usize, + pub GetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCAPropertyFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, ppropflags: *mut i32) -> ::windows_core::HRESULT, pub GetCAPropertyDisplayName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, pstrdisplayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetArchivedKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, flags: i32, pstrarchivedkey: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetConfigEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetConfigEntry: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetConfigEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetConfigEntry: usize, + pub GetConfigEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetConfigEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnodepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, strentryname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarentry: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ImportKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strcerthash: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: CERT_IMPORT_FLAGS, strkey: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetMyRoles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, proles: *mut CERTADMIN_GET_ROLES_FLAGS) -> ::windows_core::HRESULT, pub DeleteRow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: CERT_DELETE_ROW_FLAGS, date: f64, table: CVRC_TABLE, rowid: i32, pcdeleted: *mut i32) -> ::windows_core::HRESULT, @@ -3252,9 +3196,7 @@ pub struct ICertGetConfig_Vtbl { ::windows_core::imp::interface_hierarchy!(ICertManageModule, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ICertManageModule { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, strconfig: P0, strstoragelocation: P1, strpropertyname: P2, flags: i32) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, strconfig: P0, strstoragelocation: P1, strpropertyname: P2, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -3263,15 +3205,13 @@ impl ICertManageModule { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strstoragelocation.into_param().abi(), strpropertyname.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, strconfig: P0, strstoragelocation: P1, strpropertyname: P2, flags: i32, pvarproperty: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, strconfig: P0, strstoragelocation: P1, strpropertyname: P2, flags: i32, pvarproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strstoragelocation.into_param().abi(), strpropertyname.into_param().abi(), flags, pvarproperty).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), strstoragelocation.into_param().abi(), strpropertyname.into_param().abi(), flags, ::core::mem::transmute(pvarproperty)).ok() } pub unsafe fn Configure(&self, strconfig: P0, strstoragelocation: P1, flags: i32) -> ::windows_core::Result<()> where @@ -3286,14 +3226,8 @@ impl ICertManageModule { #[doc(hidden)] pub struct ICertManageModule_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, pvarproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Configure: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstoragelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -4546,9 +4480,7 @@ impl ICertRequest2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetErrorMessageText)(::windows_core::Interface::as_raw(self), hrmessage, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result + pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4569,9 +4501,7 @@ impl ICertRequest2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCAPropertyDisplayName)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), propid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result { + pub unsafe fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFullResponseProperty)(::windows_core::Interface::as_raw(self), propid, propindex, proptype, flags, &mut result__).from_abi(result__) } @@ -4583,16 +4513,10 @@ pub struct ICertRequest2_Vtbl { pub base__: ICertRequest_Vtbl, pub GetIssuedCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, requestid: i32, strserialnumber: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdisposition: *mut CR_DISP) -> ::windows_core::HRESULT, pub GetErrorMessageText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrmessage: i32, flags: i32, pstrerrormessagetext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCAProperty: usize, + pub GetCAProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, propindex: i32, proptype: i32, flags: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCAPropertyFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, ppropflags: *mut i32) -> ::windows_core::HRESULT, pub GetCAPropertyDisplayName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strconfig: ::std::mem::MaybeUninit<::windows_core::BSTR>, propid: i32, pstrdisplayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFullResponseProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFullResponseProperty: usize, + pub GetFullResponseProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4656,9 +4580,7 @@ impl ICertRequest3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetErrorMessageText)(::windows_core::Interface::as_raw(self), hrmessage, flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result + pub unsafe fn GetCAProperty(&self, strconfig: P0, propid: i32, propindex: i32, proptype: i32, flags: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4679,9 +4601,7 @@ impl ICertRequest3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCAPropertyDisplayName)(::windows_core::Interface::as_raw(self), strconfig.into_param().abi(), propid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result { + pub unsafe fn GetFullResponseProperty(&self, propid: FULL_RESPONSE_PROPERTY_ID, propindex: i32, proptype: CERT_PROPERTY_TYPE, flags: CERT_REQUEST_OUT_TYPE) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetFullResponseProperty)(::windows_core::Interface::as_raw(self), propid, propindex, proptype, flags, &mut result__).from_abi(result__) } @@ -4826,9 +4746,7 @@ impl ICertServerExit { pub unsafe fn SetContext(&self, context: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetContext)(::windows_core::Interface::as_raw(self), context).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRequestProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result + pub unsafe fn GetRequestProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4842,18 +4760,14 @@ impl ICertServerExit { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRequestAttribute)(::windows_core::Interface::as_raw(self), strattributename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCertificateProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result + pub unsafe fn GetCertificateProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCertificateProperty)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertytype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCertificateExtension(&self, strextensionname: P0, r#type: i32) -> ::windows_core::Result + pub unsafe fn GetCertificateExtension(&self, strextensionname: P0, r#type: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4891,19 +4805,10 @@ impl ICertServerExit { pub struct ICertServerExit_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub SetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRequestProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetRequestProperty: usize, + pub GetRequestProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetRequestAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strattributename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pstrattributevalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCertificateProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCertificateExtension: usize, + pub GetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCertificateExtensionFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pextflags: *mut i32) -> ::windows_core::HRESULT, pub EnumerateExtensionsSetup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: i32) -> ::windows_core::HRESULT, pub EnumerateExtensions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrextensionname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -4926,9 +4831,7 @@ impl ICertServerPolicy { pub unsafe fn SetContext(&self, context: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetContext)(::windows_core::Interface::as_raw(self), context).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRequestProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result + pub unsafe fn GetRequestProperty(&self, strpropertyname: P0, propertytype: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4942,26 +4845,20 @@ impl ICertServerPolicy { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRequestAttribute)(::windows_core::Interface::as_raw(self), strattributename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCertificateProperty(&self, strpropertyname: P0, propertytype: CERT_PROPERTY_TYPE) -> ::windows_core::Result + pub unsafe fn GetCertificateProperty(&self, strpropertyname: P0, propertytype: CERT_PROPERTY_TYPE) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCertificateProperty)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertytype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCertificateProperty(&self, strpropertyname: P0, propertytype: i32, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetCertificateProperty(&self, strpropertyname: P0, propertytype: i32, pvarpropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetCertificateProperty)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertytype, pvarpropertyvalue).ok() + (::windows_core::Interface::vtable(self).SetCertificateProperty)(::windows_core::Interface::as_raw(self), strpropertyname.into_param().abi(), propertytype, ::core::mem::transmute(pvarpropertyvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCertificateExtension(&self, strextensionname: P0, r#type: CERT_PROPERTY_TYPE) -> ::windows_core::Result + pub unsafe fn GetCertificateExtension(&self, strextensionname: P0, r#type: CERT_PROPERTY_TYPE) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4972,13 +4869,11 @@ impl ICertServerPolicy { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCertificateExtensionFlags)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCertificateExtension(&self, strextensionname: P0, r#type: i32, extflags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetCertificateExtension(&self, strextensionname: P0, r#type: i32, extflags: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetCertificateExtension)(::windows_core::Interface::as_raw(self), strextensionname.into_param().abi(), r#type, extflags, pvarvalue).ok() + (::windows_core::Interface::vtable(self).SetCertificateExtension)(::windows_core::Interface::as_raw(self), strextensionname.into_param().abi(), r#type, extflags, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn EnumerateExtensionsSetup(&self, flags: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EnumerateExtensionsSetup)(::windows_core::Interface::as_raw(self), flags).ok() @@ -5007,28 +4902,13 @@ impl ICertServerPolicy { pub struct ICertServerPolicy_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub SetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRequestProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetRequestProperty: usize, + pub GetRequestProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetRequestAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strattributename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pstrattributevalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCertificateProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCertificateProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCertificateExtension: usize, + pub GetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: CERT_PROPERTY_TYPE, pvarpropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCertificateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertytype: i32, pvarpropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: CERT_PROPERTY_TYPE, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCertificateExtensionFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pextflags: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, extflags: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCertificateExtension: usize, + pub SetCertificateExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strextensionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: i32, extflags: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumerateExtensionsSetup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: i32) -> ::windows_core::HRESULT, pub EnumerateExtensions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrextensionname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub EnumerateExtensionsClose: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5074,10 +4954,8 @@ impl ICertView { pub unsafe fn SetResultColumn(&self, columnindex: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetResultColumn)(::windows_core::Interface::as_raw(self), columnindex).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetRestriction)(::windows_core::Interface::as_raw(self), columnindex, seekoperator, sortorder, pvarvalue).ok() + pub unsafe fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetRestriction)(::windows_core::Interface::as_raw(self), columnindex, seekoperator, sortorder, ::core::mem::transmute(pvarvalue)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5100,10 +4978,7 @@ pub struct ICertView_Vtbl { pub GetColumnIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fresultcolumn: CVRC_COLUMN, strcolumnname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcolumnindex: *mut i32) -> ::windows_core::HRESULT, pub SetResultColumnCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cresultcolumn: i32) -> ::windows_core::HRESULT, pub SetResultColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, columnindex: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetRestriction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetRestriction: usize, + pub SetRestriction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub OpenView: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -5147,10 +5022,8 @@ impl ICertView2 { pub unsafe fn SetResultColumn(&self, columnindex: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetResultColumn)(::windows_core::Interface::as_raw(self), columnindex).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetRestriction)(::windows_core::Interface::as_raw(self), columnindex, seekoperator, sortorder, pvarvalue).ok() + pub unsafe fn SetRestriction(&self, columnindex: CERT_VIEW_COLUMN_INDEX, seekoperator: CERT_VIEW_SEEK_OPERATOR_FLAGS, sortorder: i32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetRestriction)(::windows_core::Interface::as_raw(self), columnindex, seekoperator, sortorder, ::core::mem::transmute(pvarvalue)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5444,9 +5317,7 @@ pub struct ICertificationAuthorities_Vtbl { ::windows_core::imp::interface_hierarchy!(ICertificationAuthority, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ICertificationAuthority { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, property: EnrollmentCAProperty) -> ::windows_core::Result { + pub unsafe fn get_Property(&self, property: EnrollmentCAProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Property)(::windows_core::Interface::as_raw(self), property, &mut result__).from_abi(result__) } @@ -5456,10 +5327,7 @@ impl ICertificationAuthority { #[doc(hidden)] pub struct ICertificationAuthority_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentCAProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Property: usize, + pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentCAProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7580,10 +7448,8 @@ impl IEnumCERTVIEWCOLUMN { pub unsafe fn GetMaxLength(&self, pmaxlength: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetMaxLength)(::windows_core::Interface::as_raw(self), pmaxlength).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), flags, pvarvalue).ok() + pub unsafe fn GetValue(&self, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), flags, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn Skip(&self, celt: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Skip)(::windows_core::Interface::as_raw(self), celt).ok() @@ -7609,10 +7475,7 @@ pub struct IEnumCERTVIEWCOLUMN_Vtbl { pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptype: *mut i32) -> ::windows_core::HRESULT, pub IsIndexed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pindexed: *mut i32) -> ::windows_core::HRESULT, pub GetMaxLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pmaxlength: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: i32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -7640,10 +7503,8 @@ impl IEnumCERTVIEWEXTENSION { pub unsafe fn GetFlags(&self, pflags: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetFlags)(::windows_core::Interface::as_raw(self), pflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), r#type, flags, pvarvalue).ok() + pub unsafe fn GetValue(&self, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), r#type, flags, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn Skip(&self, celt: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Skip)(::windows_core::Interface::as_raw(self), celt).ok() @@ -7666,10 +7527,7 @@ pub struct IEnumCERTVIEWEXTENSION_Vtbl { pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pindex: *mut i32) -> ::windows_core::HRESULT, pub GetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrout: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pflags: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: CERT_PROPERTY_TYPE, flags: ENUM_CERT_COLUMN_VALUE_FLAGS, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: i32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -7857,18 +7715,14 @@ impl IOCSPAdmin { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetSecurity)(::windows_core::Interface::as_raw(self), bstrservername.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSigningCertificates(&self, bstrservername: P0, pcacertvar: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn GetSigningCertificates(&self, bstrservername: P0, pcacertvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetSigningCertificates)(::windows_core::Interface::as_raw(self), bstrservername.into_param().abi(), pcacertvar, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetSigningCertificates)(::windows_core::Interface::as_raw(self), bstrservername.into_param().abi(), ::core::mem::transmute(pcacertvar), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetHashAlgorithms(&self, bstrservername: P0, bstrcaid: P1) -> ::windows_core::Result + pub unsafe fn GetHashAlgorithms(&self, bstrservername: P0, bstrcaid: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -7896,14 +7750,8 @@ pub struct IOCSPAdmin_Vtbl { pub Ping: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSigningCertificates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcacertvar: *const super::super::super::System::Variant::VARIANT, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSigningCertificates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetHashAlgorithms: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcaid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetHashAlgorithms: usize, + pub GetSigningCertificates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcacertvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetHashAlgorithms: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcaid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7920,9 +7768,7 @@ impl IOCSPCAConfiguration { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Identifier)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CACertificate(&self) -> ::windows_core::Result { + pub unsafe fn CACertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CACertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -7943,16 +7789,15 @@ impl IOCSPCAConfiguration { pub unsafe fn SetSigningFlags(&self, newval: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSigningFlags)(::windows_core::Interface::as_raw(self), newval).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SigningCertificate(&self) -> ::windows_core::Result { + pub unsafe fn SigningCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SigningCertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSigningCertificate(&self, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSigningCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(newval)).ok() + pub unsafe fn SetSigningCertificate(&self, newval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSigningCertificate)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } pub unsafe fn ReminderDuration(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7983,31 +7828,29 @@ impl IOCSPCAConfiguration { { (::windows_core::Interface::vtable(self).SetProviderCLSID)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ProviderProperties(&self) -> ::windows_core::Result { + pub unsafe fn ProviderProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ProviderProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProviderProperties(&self, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProviderProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(newval)).ok() + pub unsafe fn SetProviderProperties(&self, newval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetProviderProperties)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } pub unsafe fn Modified(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Modified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LocalRevocationInformation(&self) -> ::windows_core::Result { + pub unsafe fn LocalRevocationInformation(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LocalRevocationInformation)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetLocalRevocationInformation(&self, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetLocalRevocationInformation)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(newval)).ok() + pub unsafe fn SetLocalRevocationInformation(&self, newval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetLocalRevocationInformation)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } pub unsafe fn SigningCertificateTemplate(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -8036,22 +7879,13 @@ impl IOCSPCAConfiguration { pub struct IOCSPCAConfiguration_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub Identifier: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CACertificate: usize, + pub CACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub HashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SigningFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut u32) -> ::windows_core::HRESULT, pub SetSigningFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SigningCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SigningCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSigningCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSigningCertificate: usize, + pub SigningCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSigningCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ReminderDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut u32) -> ::windows_core::HRESULT, pub SetReminderDuration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: u32) -> ::windows_core::HRESULT, pub ErrorCode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut u32) -> ::windows_core::HRESULT, @@ -8059,23 +7893,11 @@ pub struct IOCSPCAConfiguration_Vtbl { pub KeySpec: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut u32) -> ::windows_core::HRESULT, pub ProviderCLSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetProviderCLSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ProviderProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ProviderProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProviderProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProviderProperties: usize, + pub ProviderProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProviderProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LocalRevocationInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LocalRevocationInformation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetLocalRevocationInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetLocalRevocationInformation: usize, + pub LocalRevocationInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetLocalRevocationInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SigningCertificateTemplate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSigningCertificateTemplate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub CAConfig: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -8096,9 +7918,7 @@ impl IOCSPCAConfigurationCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -8106,23 +7926,22 @@ impl IOCSPCAConfigurationCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_ItemByName(&self, bstridentifier: P0) -> ::windows_core::Result + pub unsafe fn get_ItemByName(&self, bstridentifier: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_ItemByName)(::windows_core::Interface::as_raw(self), bstridentifier.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateCAConfiguration(&self, bstridentifier: P0, varcacert: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateCAConfiguration(&self, bstridentifier: P0, varcacert: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateCAConfiguration)(::windows_core::Interface::as_raw(self), bstridentifier.into_param().abi(), ::core::mem::transmute(varcacert), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateCAConfiguration)(::windows_core::Interface::as_raw(self), bstridentifier.into_param().abi(), varcacert.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn DeleteCAConfiguration(&self, bstridentifier: P0) -> ::windows_core::Result<()> where @@ -8137,18 +7956,12 @@ impl IOCSPCAConfigurationCollection { pub struct IOCSPCAConfigurationCollection_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_ItemByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_ItemByName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateCAConfiguration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, varcacert: super::super::super::System::Variant::VARIANT, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub get_ItemByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub CreateCAConfiguration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>, varcacert: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateCAConfiguration: usize, pub DeleteCAConfiguration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstridentifier: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -8167,16 +7980,15 @@ impl IOCSPProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(newval)).ok() + pub unsafe fn SetValue(&self, newval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } pub unsafe fn Modified(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -8189,14 +8001,8 @@ impl IOCSPProperty { pub struct IOCSPProperty_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Modified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -8214,9 +8020,7 @@ impl IOCSPPropertyCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -8224,23 +8028,21 @@ impl IOCSPPropertyCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_ItemByName(&self, bstrpropname: P0) -> ::windows_core::Result + pub unsafe fn get_ItemByName(&self, bstrpropname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_ItemByName)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateProperty(&self, bstrpropname: P0, pvarpropvalue: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateProperty(&self, bstrpropname: P0, pvarpropvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateProperty)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), pvarpropvalue, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateProperty)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), ::core::mem::transmute(pvarpropvalue), &mut result__).from_abi(result__) } pub unsafe fn DeleteProperty(&self, bstrpropname: P0) -> ::windows_core::Result<()> where @@ -8248,14 +8050,10 @@ impl IOCSPPropertyCollection { { (::windows_core::Interface::vtable(self).DeleteProperty)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeFromProperties(&self, pvarproperties: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InitializeFromProperties)(::windows_core::Interface::as_raw(self), pvarproperties).ok() + pub unsafe fn InitializeFromProperties(&self, pvarproperties: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).InitializeFromProperties)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarproperties)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAllProperties(&self) -> ::windows_core::Result { + pub unsafe fn GetAllProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -8266,28 +8064,16 @@ impl IOCSPPropertyCollection { pub struct IOCSPPropertyCollection_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_ItemByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_ItemByName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarpropvalue: *const super::super::super::System::Variant::VARIANT, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub get_ItemByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub CreateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarpropvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateProperty: usize, pub DeleteProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeFromProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarproperties: *const super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InitializeFromProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAllProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarproperties: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllProperties: usize, + pub InitializeFromProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarproperties: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetAllProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarproperties: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -13477,9 +13263,7 @@ pub struct IX509CertificateRevocationListEntry_Vtbl { ::windows_core::imp::interface_hierarchy!(IX509CertificateTemplate, ::windows_core::IUnknown, super::super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IX509CertificateTemplate { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result { + pub unsafe fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Property)(::windows_core::Interface::as_raw(self), property, &mut result__).from_abi(result__) } @@ -13489,10 +13273,7 @@ impl IX509CertificateTemplate { #[doc(hidden)] pub struct IX509CertificateTemplate_Vtbl { pub base__: super::super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Property: usize, + pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -13519,16 +13300,15 @@ impl IX509CertificateTemplateWritable { { (::windows_core::Interface::vtable(self).Commit)(::windows_core::Interface::as_raw(self), commitflags, strservercontext.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result { + pub unsafe fn get_Property(&self, property: EnrollmentTemplateProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Property)(::windows_core::Interface::as_raw(self), property, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Property(&self, property: EnrollmentTemplateProperty, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), property, ::core::mem::transmute(value)).ok() + pub unsafe fn put_Property(&self, property: EnrollmentTemplateProperty, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), property, value.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -13547,14 +13327,8 @@ pub struct IX509CertificateTemplateWritable_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Initialize: usize, pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commitflags: CommitTemplateFlags, strservercontext: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Property: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, value: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_Property: usize, + pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: EnrollmentTemplateProperty, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Template: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -14234,14 +14008,13 @@ impl IX509EnrollmentPolicyServer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QueryChanges)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitializeImport(&self, val: super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InitializeImport)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(val)).ok() + pub unsafe fn InitializeImport(&self, val: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).InitializeImport)(::windows_core::Interface::as_raw(self), val.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Export(&self, exportflags: X509EnrollmentPolicyExportFlags) -> ::windows_core::Result { + pub unsafe fn Export(&self, exportflags: X509EnrollmentPolicyExportFlags) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Export)(::windows_core::Interface::as_raw(self), exportflags, &mut result__).from_abi(result__) } @@ -14290,14 +14063,8 @@ pub struct IX509EnrollmentPolicyServer_Vtbl { pub GetAuthFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *mut X509EnrollmentAuthFlags) -> ::windows_core::HRESULT, pub SetCredential: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndparent: i32, flag: X509EnrollmentAuthFlags, strcredential: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub QueryChanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *mut super::super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitializeImport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, val: super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InitializeImport: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Export: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, exportflags: X509EnrollmentPolicyExportFlags, pval: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Export: usize, + pub InitializeImport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Export: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, exportflags: X509EnrollmentPolicyExportFlags, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Cost: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *mut u32) -> ::windows_core::HRESULT, pub SetCost: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: u32) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/impl.rs b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/impl.rs index ceddeea306..411a19ab4c 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/impl.rs @@ -1,17 +1,17 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertSrvSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CAErrorId(&self) -> ::windows_core::Result; fn CAErrorString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitializeDefaults(&self, bserver: super::super::Foundation::VARIANT_BOOL, bclient: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows_core::Result; - fn SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn IsPropertyEditable(&self, propertyid: CASetupProperty) -> ::windows_core::Result; - fn GetSupportedCATypes(&self) -> ::windows_core::Result; - fn GetProviderNameList(&self) -> ::windows_core::Result; - fn GetKeyLengthList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result; - fn GetHashAlgorithmList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result; - fn GetPrivateKeyContainerList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetSupportedCATypes(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetProviderNameList(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetKeyLengthList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetHashAlgorithmList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetPrivateKeyContainerList(&self, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetExistingCACertificates(&self) -> ::windows_core::Result; fn CAImportPFX(&self, bstrfilename: &::windows_core::BSTR, bstrpasswd: &::windows_core::BSTR, boverwriteexistingkey: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; fn SetCADistinguishedName(&self, bstrcadn: &::windows_core::BSTR, bignoreunicode: super::super::Foundation::VARIANT_BOOL, boverwriteexistingkey: super::super::Foundation::VARIANT_BOOL, boverwriteexistingcainds: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -22,9 +22,9 @@ pub trait ICertSrvSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl fn PreUnInstall(&self, bclientonly: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn PostUnInstall(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertSrvSetup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertSrvSetup_Vtbl { pub const fn new, Impl: ICertSrvSetup_Impl, const OFFSET: isize>() -> ICertSrvSetup_Vtbl { unsafe extern "system" fn CAErrorId, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -54,7 +54,7 @@ impl ICertSrvSetup_Vtbl { let this = (*this).get_impl(); this.InitializeDefaults(::core::mem::transmute_copy(&bserver), ::core::mem::transmute_copy(&bclient)).into() } - unsafe extern "system" fn GetCASetupProperty, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCASetupProperty, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCASetupProperty(::core::mem::transmute_copy(&propertyid)) { @@ -65,7 +65,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCASetupProperty, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCASetupProperty, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCASetupProperty(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ppropertyvalue)).into() @@ -81,7 +81,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetSupportedCATypes, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcatypes: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSupportedCATypes, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcatypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSupportedCATypes() { @@ -92,7 +92,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProviderNameList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProviderNameList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProviderNameList() { @@ -103,7 +103,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetKeyLengthList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetKeyLengthList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetKeyLengthList(::core::mem::transmute(&bstrprovidername)) { @@ -114,7 +114,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetHashAlgorithmList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetHashAlgorithmList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetHashAlgorithmList(::core::mem::transmute(&bstrprovidername)) { @@ -125,7 +125,7 @@ impl ICertSrvSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPrivateKeyContainerList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPrivateKeyContainerList, Impl: ICertSrvSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPrivateKeyContainerList(::core::mem::transmute(&bstrprovidername)) { @@ -221,8 +221,8 @@ impl ICertSrvSetup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertSrvSetupKeyInformation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetProviderName(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -234,12 +234,12 @@ pub trait ICertSrvSetupKeyInformation_Impl: Sized + super::super::System::Com::I fn SetContainerName(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn HashAlgorithm(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetHashAlgorithm(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ExistingCACertificate(&self) -> ::windows_core::Result; - fn SetExistingCACertificate(&self, varval: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ExistingCACertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExistingCACertificate(&self, varval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertSrvSetupKeyInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertSrvSetupKeyInformation_Vtbl { pub const fn new, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>() -> ICertSrvSetupKeyInformation_Vtbl { unsafe extern "system" fn ProviderName, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -322,7 +322,7 @@ impl ICertSrvSetupKeyInformation_Vtbl { let this = (*this).get_impl(); this.SetHashAlgorithm(::core::mem::transmute(&bstrval)).into() } - unsafe extern "system" fn ExistingCACertificate, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExistingCACertificate, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExistingCACertificate() { @@ -333,7 +333,7 @@ impl ICertSrvSetupKeyInformation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExistingCACertificate, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExistingCACertificate, Impl: ICertSrvSetupKeyInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExistingCACertificate(::core::mem::transmute(&varval)).into() @@ -358,17 +358,17 @@ impl ICertSrvSetupKeyInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertSrvSetupKeyInformationCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn Add(&self, pikeyinformation: ::core::option::Option<&ICertSrvSetupKeyInformation>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertSrvSetupKeyInformationCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertSrvSetupKeyInformationCollection_Vtbl { pub const fn new, Impl: ICertSrvSetupKeyInformationCollection_Impl, const OFFSET: isize>() -> ICertSrvSetupKeyInformationCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ICertSrvSetupKeyInformationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -382,7 +382,7 @@ impl ICertSrvSetupKeyInformationCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ICertSrvSetupKeyInformationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ICertSrvSetupKeyInformationCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -421,19 +421,19 @@ impl ICertSrvSetupKeyInformationCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificateEnrollmentPolicyServerSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ErrorString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitializeInstallDefaults(&self) -> ::windows_core::Result<()>; - fn GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows_core::Result; - fn SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Install(&self) -> ::windows_core::Result<()>; - fn UnInstall(&self, pauthkeybasedrenewal: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn UnInstall(&self, pauthkeybasedrenewal: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificateEnrollmentPolicyServerSetup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificateEnrollmentPolicyServerSetup_Vtbl { pub const fn new, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>() -> ICertificateEnrollmentPolicyServerSetup_Vtbl { unsafe extern "system" fn ErrorString, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -452,7 +452,7 @@ impl ICertificateEnrollmentPolicyServerSetup_Vtbl { let this = (*this).get_impl(); this.InitializeInstallDefaults().into() } - unsafe extern "system" fn GetProperty, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&propertyid)) { @@ -463,7 +463,7 @@ impl ICertificateEnrollmentPolicyServerSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ppropertyvalue)).into() @@ -473,7 +473,7 @@ impl ICertificateEnrollmentPolicyServerSetup_Vtbl { let this = (*this).get_impl(); this.Install().into() } - unsafe extern "system" fn UnInstall, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pauthkeybasedrenewal: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UnInstall, Impl: ICertificateEnrollmentPolicyServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pauthkeybasedrenewal: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.UnInstall(::core::mem::transmute_copy(&pauthkeybasedrenewal)).into() @@ -492,20 +492,20 @@ impl ICertificateEnrollmentPolicyServerSetup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICertificateEnrollmentServerSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ErrorString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitializeInstallDefaults(&self) -> ::windows_core::Result<()>; - fn GetProperty(&self, propertyid: CESSetupProperty) -> ::windows_core::Result; - fn SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, propertyid: CESSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetApplicationPoolCredentials(&self, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Install(&self) -> ::windows_core::Result<()>; - fn UnInstall(&self, pcaconfig: *const super::super::System::Variant::VARIANT, pauthentication: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn UnInstall(&self, pcaconfig: *const ::windows_core::VARIANT, pauthentication: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICertificateEnrollmentServerSetup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICertificateEnrollmentServerSetup_Vtbl { pub const fn new, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>() -> ICertificateEnrollmentServerSetup_Vtbl { unsafe extern "system" fn ErrorString, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -524,7 +524,7 @@ impl ICertificateEnrollmentServerSetup_Vtbl { let this = (*this).get_impl(); this.InitializeInstallDefaults().into() } - unsafe extern "system" fn GetProperty, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&propertyid)) { @@ -535,7 +535,7 @@ impl ICertificateEnrollmentServerSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ppropertyvalue)).into() @@ -550,7 +550,7 @@ impl ICertificateEnrollmentServerSetup_Vtbl { let this = (*this).get_impl(); this.Install().into() } - unsafe extern "system" fn UnInstall, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcaconfig: *const super::super::System::Variant::VARIANT, pauthentication: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UnInstall, Impl: ICertificateEnrollmentServerSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcaconfig: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pauthentication: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.UnInstall(::core::mem::transmute_copy(&pcaconfig), ::core::mem::transmute_copy(&pauthentication)).into() @@ -570,25 +570,25 @@ impl ICertificateEnrollmentServerSetup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSCEPSetup_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MSCEPErrorId(&self) -> ::windows_core::Result; fn MSCEPErrorString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitializeDefaults(&self) -> ::windows_core::Result<()>; - fn GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows_core::Result; - fn SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetAccountInformation(&self, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsMSCEPStoreEmpty(&self) -> ::windows_core::Result; - fn GetProviderNameList(&self, bexchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; - fn GetKeyLengthList(&self, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetProviderNameList(&self, bexchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetKeyLengthList(&self, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn Install(&self) -> ::windows_core::Result<()>; fn PreUnInstall(&self) -> ::windows_core::Result<()>; fn PostUnInstall(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSCEPSetup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSCEPSetup_Vtbl { pub const fn new, Impl: IMSCEPSetup_Impl, const OFFSET: isize>() -> IMSCEPSetup_Vtbl { unsafe extern "system" fn MSCEPErrorId, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -618,7 +618,7 @@ impl IMSCEPSetup_Vtbl { let this = (*this).get_impl(); this.InitializeDefaults().into() } - unsafe extern "system" fn GetMSCEPSetupProperty, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetMSCEPSetupProperty, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetMSCEPSetupProperty(::core::mem::transmute_copy(&propertyid)) { @@ -629,7 +629,7 @@ impl IMSCEPSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetMSCEPSetupProperty, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetMSCEPSetupProperty, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetMSCEPSetupProperty(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ppropertyvalue)).into() @@ -650,7 +650,7 @@ impl IMSCEPSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetProviderNameList, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProviderNameList, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProviderNameList(::core::mem::transmute_copy(&bexchange)) { @@ -661,7 +661,7 @@ impl IMSCEPSetup_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetKeyLengthList, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetKeyLengthList, Impl: IMSCEPSetup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetKeyLengthList(::core::mem::transmute_copy(&bexchange), ::core::mem::transmute(&bstrprovidername)) { diff --git a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/mod.rs b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/mod.rs index fed9d6aec6..5b2a9fe809 100644 --- a/crates/libs/windows/src/Windows/Win32/Security/Cryptography/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Security/Cryptography/mod.rs @@ -2888,54 +2888,40 @@ impl ICertSrvSetup { { (::windows_core::Interface::vtable(self).InitializeDefaults)(::windows_core::Interface::as_raw(self), bserver.into_param().abi(), bclient.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows_core::Result { + pub unsafe fn GetCASetupProperty(&self, propertyid: CASetupProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCASetupProperty)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCASetupProperty)(::windows_core::Interface::as_raw(self), propertyid, ppropertyvalue).ok() + pub unsafe fn SetCASetupProperty(&self, propertyid: CASetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetCASetupProperty)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(ppropertyvalue)).ok() } pub unsafe fn IsPropertyEditable(&self, propertyid: CASetupProperty) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsPropertyEditable)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSupportedCATypes(&self) -> ::windows_core::Result { + pub unsafe fn GetSupportedCATypes(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetSupportedCATypes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProviderNameList(&self) -> ::windows_core::Result { + pub unsafe fn GetProviderNameList(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProviderNameList)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetKeyLengthList(&self, bstrprovidername: P0) -> ::windows_core::Result + pub unsafe fn GetKeyLengthList(&self, bstrprovidername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetKeyLengthList)(::windows_core::Interface::as_raw(self), bstrprovidername.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetHashAlgorithmList(&self, bstrprovidername: P0) -> ::windows_core::Result + pub unsafe fn GetHashAlgorithmList(&self, bstrprovidername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetHashAlgorithmList)(::windows_core::Interface::as_raw(self), bstrprovidername.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPrivateKeyContainerList(&self, bstrprovidername: P0) -> ::windows_core::Result + pub unsafe fn GetPrivateKeyContainerList(&self, bstrprovidername: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3010,35 +2996,14 @@ pub struct ICertSrvSetup_Vtbl { pub CAErrorId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, pub CAErrorString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub InitializeDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bserver: super::super::Foundation::VARIANT_BOOL, bclient: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCASetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCASetupProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCASetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCASetupProperty: usize, + pub GetCASetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCASetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsPropertyEditable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CASetupProperty, pbeditable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSupportedCATypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcatypes: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSupportedCATypes: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProviderNameList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProviderNameList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetKeyLengthList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetKeyLengthList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetHashAlgorithmList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetHashAlgorithmList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPrivateKeyContainerList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPrivateKeyContainerList: usize, + pub GetSupportedCATypes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcatypes: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetProviderNameList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetKeyLengthList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetHashAlgorithmList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetPrivateKeyContainerList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetExistingCACertificates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3113,16 +3078,15 @@ impl ICertSrvSetupKeyInformation { { (::windows_core::Interface::vtable(self).SetHashAlgorithm)(::windows_core::Interface::as_raw(self), bstrval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExistingCACertificate(&self) -> ::windows_core::Result { + pub unsafe fn ExistingCACertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ExistingCACertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExistingCACertificate(&self, varval: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetExistingCACertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varval)).ok() + pub unsafe fn SetExistingCACertificate(&self, varval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetExistingCACertificate)(::windows_core::Interface::as_raw(self), varval.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3140,14 +3104,8 @@ pub struct ICertSrvSetupKeyInformation_Vtbl { pub SetContainerName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub HashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExistingCACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExistingCACertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExistingCACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExistingCACertificate: usize, + pub ExistingCACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExistingCACertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3164,9 +3122,7 @@ impl ICertSrvSetupKeyInformationCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -3189,10 +3145,7 @@ impl ICertSrvSetupKeyInformationCollection { pub struct ICertSrvSetupKeyInformationCollection_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pikeyinformation: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3217,24 +3170,18 @@ impl ICertificateEnrollmentPolicyServerSetup { pub unsafe fn InitializeInstallDefaults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).InitializeInstallDefaults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, propertyid: CEPSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), propertyid, ppropertyvalue).ok() + pub unsafe fn SetProperty(&self, propertyid: CEPSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(ppropertyvalue)).ok() } pub unsafe fn Install(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Install)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UnInstall(&self, pauthkeybasedrenewal: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).UnInstall)(::windows_core::Interface::as_raw(self), pauthkeybasedrenewal).ok() + pub unsafe fn UnInstall(&self, pauthkeybasedrenewal: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).UnInstall)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pauthkeybasedrenewal)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3244,19 +3191,10 @@ pub struct ICertificateEnrollmentPolicyServerSetup_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub ErrorString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub InitializeInstallDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CEPSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Install: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pauthkeybasedrenewal: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UnInstall: usize, + pub UnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pauthkeybasedrenewal: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3276,16 +3214,12 @@ impl ICertificateEnrollmentServerSetup { pub unsafe fn InitializeInstallDefaults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).InitializeInstallDefaults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, propertyid: CESSetupProperty) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, propertyid: CESSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), propertyid, ppropertyvalue).ok() + pub unsafe fn SetProperty(&self, propertyid: CESSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(ppropertyvalue)).ok() } pub unsafe fn SetApplicationPoolCredentials(&self, bstrusername: P0, bstrpassword: P1) -> ::windows_core::Result<()> where @@ -3297,10 +3231,8 @@ impl ICertificateEnrollmentServerSetup { pub unsafe fn Install(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Install)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UnInstall(&self, pcaconfig: *const super::super::System::Variant::VARIANT, pauthentication: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).UnInstall)(::windows_core::Interface::as_raw(self), pcaconfig, pauthentication).ok() + pub unsafe fn UnInstall(&self, pcaconfig: *const ::windows_core::VARIANT, pauthentication: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).UnInstall)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pcaconfig), ::core::mem::transmute(pauthentication)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3310,20 +3242,11 @@ pub struct ICertificateEnrollmentServerSetup_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub ErrorString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub InitializeInstallDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: CESSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetApplicationPoolCredentials: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Install: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcaconfig: *const super::super::System::Variant::VARIANT, pauthentication: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UnInstall: usize, + pub UnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcaconfig: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pauthentication: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3347,16 +3270,12 @@ impl IMSCEPSetup { pub unsafe fn InitializeDefaults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).InitializeDefaults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows_core::Result { + pub unsafe fn GetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetMSCEPSetupProperty)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetMSCEPSetupProperty)(::windows_core::Interface::as_raw(self), propertyid, ppropertyvalue).ok() + pub unsafe fn SetMSCEPSetupProperty(&self, propertyid: MSCEPSetupProperty, ppropertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetMSCEPSetupProperty)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(ppropertyvalue)).ok() } pub unsafe fn SetAccountInformation(&self, bstrusername: P0, bstrpassword: P1) -> ::windows_core::Result<()> where @@ -3369,18 +3288,14 @@ impl IMSCEPSetup { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsMSCEPStoreEmpty)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProviderNameList(&self, bexchange: P0) -> ::windows_core::Result + pub unsafe fn GetProviderNameList(&self, bexchange: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProviderNameList)(::windows_core::Interface::as_raw(self), bexchange.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetKeyLengthList(&self, bexchange: P0, bstrprovidername: P1) -> ::windows_core::Result + pub unsafe fn GetKeyLengthList(&self, bexchange: P0, bstrprovidername: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -3406,24 +3321,12 @@ pub struct IMSCEPSetup_Vtbl { pub MSCEPErrorId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, pub MSCEPErrorString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub InitializeDefaults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetMSCEPSetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetMSCEPSetupProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetMSCEPSetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, ppropertyvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetMSCEPSetupProperty: usize, + pub GetMSCEPSetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetMSCEPSetupProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: MSCEPSetupProperty, ppropertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetAccountInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsMSCEPStoreEmpty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbempty: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProviderNameList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProviderNameList: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetKeyLengthList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetKeyLengthList: usize, + pub GetProviderNameList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetKeyLengthList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bexchange: super::super::Foundation::VARIANT_BOOL, bstrprovidername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Install: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub PreUnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub PostUnInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/impl.rs index 9e877df979..6ad80913b6 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/impl.rs @@ -15,17 +15,13 @@ impl IDedupBackupSupport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDedupChunkLibrary_Impl: Sized { fn InitializeForPushBuffers(&self) -> ::windows_core::Result<()>; fn Uninitialize(&self) -> ::windows_core::Result<()>; - fn SetParameter(&self, dwparamtype: u32, vparamvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetParameter(&self, dwparamtype: u32, vparamvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn StartChunking(&self, iiditeratorinterfaceid: &::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDedupChunkLibrary {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDedupChunkLibrary_Vtbl { pub const fn new, Impl: IDedupChunkLibrary_Impl, const OFFSET: isize>() -> IDedupChunkLibrary_Vtbl { unsafe extern "system" fn InitializeForPushBuffers, Impl: IDedupChunkLibrary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -38,7 +34,7 @@ impl IDedupChunkLibrary_Vtbl { let this = (*this).get_impl(); this.Uninitialize().into() } - unsafe extern "system" fn SetParameter, Impl: IDedupChunkLibrary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwparamtype: u32, vparamvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParameter, Impl: IDedupChunkLibrary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwparamtype: u32, vparamvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParameter(::core::mem::transmute_copy(&dwparamtype), ::core::mem::transmute(&vparamvalue)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/mod.rs b/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/mod.rs index 3a9f74a6e6..11b72d5265 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/DataDeduplication/mod.rs @@ -23,10 +23,11 @@ impl IDedupChunkLibrary { pub unsafe fn Uninitialize(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Uninitialize)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameter(&self, dwparamtype: u32, vparamvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), dwparamtype, ::core::mem::transmute(vparamvalue)).ok() + pub unsafe fn SetParameter(&self, dwparamtype: u32, vparamvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), dwparamtype, vparamvalue.into_param().abi()).ok() } pub unsafe fn StartChunking(&self, iiditeratorinterfaceid: ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -39,10 +40,7 @@ pub struct IDedupChunkLibrary_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub InitializeForPushBuffers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Uninitialize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwparamtype: u32, vparamvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetParameter: usize, + pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwparamtype: u32, vparamvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub StartChunking: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iiditeratorinterfaceid: ::windows_core::GUID, ppchunksenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDedupDataPort, IDedupDataPort_Vtbl, 0x7963d734_40a9_4ea3_bbf6_5a89d26f7ae8); diff --git a/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/impl.rs index 69d66a55bc..6cca4ba570 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/impl.rs @@ -1,9 +1,9 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DIFsrmClassificationEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DIFsrmClassificationEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DIFsrmClassificationEvents_Vtbl { pub const fn new, Impl: DIFsrmClassificationEvents_Impl, const OFFSET: isize>() -> DIFsrmClassificationEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -12,14 +12,14 @@ impl DIFsrmClassificationEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmAccessDeniedRemediationClient_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Show(&self, parentwnd: usize, accesspath: &::windows_core::BSTR, errortype: AdrClientErrorType, flags: i32, windowtitle: &::windows_core::BSTR, windowmessage: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmAccessDeniedRemediationClient {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmAccessDeniedRemediationClient_Vtbl { pub const fn new, Impl: IFsrmAccessDeniedRemediationClient_Impl, const OFFSET: isize>() -> IFsrmAccessDeniedRemediationClient_Vtbl { unsafe extern "system" fn Show, Impl: IFsrmAccessDeniedRemediationClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, parentwnd: usize, accesspath: ::std::mem::MaybeUninit<::windows_core::BSTR>, errortype: AdrClientErrorType, flags: i32, windowtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, windowmessage: ::std::mem::MaybeUninit<::windows_core::BSTR>, result: *mut i32) -> ::windows_core::HRESULT { @@ -39,8 +39,8 @@ impl IFsrmAccessDeniedRemediationClient_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmAction_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::GUID>; fn ActionType(&self) -> ::windows_core::Result; @@ -48,9 +48,9 @@ pub trait IFsrmAction_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetRunLimitInterval(&self, minutes: i32) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmAction_Vtbl { pub const fn new, Impl: IFsrmAction_Impl, const OFFSET: isize>() -> IFsrmAction_Vtbl { unsafe extern "system" fn Id, Impl: IFsrmAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -109,8 +109,8 @@ impl IFsrmAction_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmActionCommand_Impl: Sized + IFsrmAction_Impl { fn ExecutablePath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetExecutablePath(&self, executablepath: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -127,9 +127,9 @@ pub trait IFsrmActionCommand_Impl: Sized + IFsrmAction_Impl { fn LogResult(&self) -> ::windows_core::Result; fn SetLogResult(&self, logresults: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmActionCommand {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmActionCommand_Vtbl { pub const fn new, Impl: IFsrmActionCommand_Impl, const OFFSET: isize>() -> IFsrmActionCommand_Vtbl { unsafe extern "system" fn ExecutablePath, Impl: IFsrmActionCommand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, executablepath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -266,8 +266,8 @@ impl IFsrmActionCommand_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmActionEmail_Impl: Sized + IFsrmAction_Impl { fn MailFrom(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMailFrom(&self, mailfrom: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -284,9 +284,9 @@ pub trait IFsrmActionEmail_Impl: Sized + IFsrmAction_Impl { fn MessageText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMessageText(&self, messagetext: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmActionEmail {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmActionEmail_Vtbl { pub const fn new, Impl: IFsrmActionEmail_Impl, const OFFSET: isize>() -> IFsrmActionEmail_Vtbl { unsafe extern "system" fn MailFrom, Impl: IFsrmActionEmail_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, mailfrom: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -423,15 +423,15 @@ impl IFsrmActionEmail_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmActionEmail2_Impl: Sized + IFsrmActionEmail_Impl { fn AttachmentFileListSize(&self) -> ::windows_core::Result; fn SetAttachmentFileListSize(&self, attachmentfilelistsize: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmActionEmail2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmActionEmail2_Vtbl { pub const fn new, Impl: IFsrmActionEmail2_Impl, const OFFSET: isize>() -> IFsrmActionEmail2_Vtbl { unsafe extern "system" fn AttachmentFileListSize, Impl: IFsrmActionEmail2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attachmentfilelistsize: *mut i32) -> ::windows_core::HRESULT { @@ -460,17 +460,17 @@ impl IFsrmActionEmail2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmActionEventLog_Impl: Sized + IFsrmAction_Impl { fn EventType(&self) -> ::windows_core::Result; fn SetEventType(&self, eventtype: FsrmEventType) -> ::windows_core::Result<()>; fn MessageText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMessageText(&self, messagetext: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmActionEventLog {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmActionEventLog_Vtbl { pub const fn new, Impl: IFsrmActionEventLog_Impl, const OFFSET: isize>() -> IFsrmActionEventLog_Vtbl { unsafe extern "system" fn EventType, Impl: IFsrmActionEventLog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eventtype: *mut FsrmEventType) -> ::windows_core::HRESULT { @@ -517,17 +517,17 @@ impl IFsrmActionEventLog_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmActionReport_Impl: Sized + IFsrmAction_Impl { fn ReportTypes(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetReportTypes(&self, reporttypes: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn MailTo(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMailTo(&self, mailto: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmActionReport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmActionReport_Vtbl { pub const fn new, Impl: IFsrmActionReport_Impl, const OFFSET: isize>() -> IFsrmActionReport_Vtbl { unsafe extern "system" fn ReportTypes, Impl: IFsrmActionReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttypes: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -574,16 +574,16 @@ impl IFsrmActionReport_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmAutoApplyQuota_Impl: Sized + IFsrmQuotaObject_Impl { fn ExcludeFolders(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetExcludeFolders(&self, folders: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn CommitAndUpdateDerived(&self, commitoptions: FsrmCommitOptions, applyoptions: FsrmTemplateApplyOptions) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmAutoApplyQuota {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmAutoApplyQuota_Vtbl { pub const fn new, Impl: IFsrmAutoApplyQuota_Impl, const OFFSET: isize>() -> IFsrmAutoApplyQuota_Vtbl { unsafe extern "system" fn ExcludeFolders, Impl: IFsrmAutoApplyQuota_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, folders: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -624,8 +624,8 @@ impl IFsrmAutoApplyQuota_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmClassificationManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ClassificationReportFormats(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetClassificationReportFormats(&self, formats: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; @@ -655,9 +655,9 @@ pub trait IFsrmClassificationManager_Impl: Sized + super::super::System::Com::ID fn SetFileProperty(&self, filepath: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, propertyvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ClearFileProperty(&self, filepath: &::windows_core::BSTR, property: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmClassificationManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmClassificationManager_Vtbl { pub const fn new, Impl: IFsrmClassificationManager_Impl, const OFFSET: isize>() -> IFsrmClassificationManager_Vtbl { unsafe extern "system" fn ClassificationReportFormats, Impl: IFsrmClassificationManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, formats: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -944,14 +944,14 @@ impl IFsrmClassificationManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmClassificationManager2_Impl: Sized + IFsrmClassificationManager_Impl { fn ClassifyFiles(&self, filepaths: *const super::super::System::Com::SAFEARRAY, propertynames: *const super::super::System::Com::SAFEARRAY, propertyvalues: *const super::super::System::Com::SAFEARRAY, options: FsrmGetFilePropertyOptions) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmClassificationManager2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmClassificationManager2_Vtbl { pub const fn new, Impl: IFsrmClassificationManager2_Impl, const OFFSET: isize>() -> IFsrmClassificationManager2_Vtbl { unsafe extern "system" fn ClassifyFiles, Impl: IFsrmClassificationManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepaths: *const super::super::System::Com::SAFEARRAY, propertynames: *const super::super::System::Com::SAFEARRAY, propertyvalues: *const super::super::System::Com::SAFEARRAY, options: FsrmGetFilePropertyOptions) -> ::windows_core::HRESULT { @@ -965,8 +965,8 @@ impl IFsrmClassificationManager2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmClassificationRule_Impl: Sized + IFsrmRule_Impl { fn ExecutionOption(&self) -> ::windows_core::Result; fn SetExecutionOption(&self, executionoption: FsrmExecutionOption) -> ::windows_core::Result<()>; @@ -975,9 +975,9 @@ pub trait IFsrmClassificationRule_Impl: Sized + IFsrmRule_Impl { fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetValue(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmClassificationRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmClassificationRule_Vtbl { pub const fn new, Impl: IFsrmClassificationRule_Impl, const OFFSET: isize>() -> IFsrmClassificationRule_Vtbl { unsafe extern "system" fn ExecutionOption, Impl: IFsrmClassificationRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, executionoption: *mut FsrmExecutionOption) -> ::windows_core::HRESULT { @@ -1042,8 +1042,8 @@ impl IFsrmClassificationRule_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmClassifierModuleDefinition_Impl: Sized + IFsrmPipelineModuleDefinition_Impl { fn PropertiesAffected(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetPropertiesAffected(&self, propertiesaffected: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; @@ -1052,9 +1052,9 @@ pub trait IFsrmClassifierModuleDefinition_Impl: Sized + IFsrmPipelineModuleDefin fn NeedsExplicitValue(&self) -> ::windows_core::Result; fn SetNeedsExplicitValue(&self, needsexplicitvalue: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmClassifierModuleDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmClassifierModuleDefinition_Vtbl { pub const fn new, Impl: IFsrmClassifierModuleDefinition_Impl, const OFFSET: isize>() -> IFsrmClassifierModuleDefinition_Vtbl { unsafe extern "system" fn PropertiesAffected, Impl: IFsrmClassifierModuleDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertiesaffected: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -1119,22 +1119,22 @@ impl IFsrmClassifierModuleDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmClassifierModuleImplementation_Impl: Sized + IFsrmPipelineModuleImplementation_Impl { - fn LastModified(&self) -> ::windows_core::Result; + fn LastModified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn UseRulesAndDefinitions(&self, rules: ::core::option::Option<&IFsrmCollection>, propertydefinitions: ::core::option::Option<&IFsrmCollection>) -> ::windows_core::Result<()>; fn OnBeginFile(&self, propertybag: ::core::option::Option<&IFsrmPropertyBag>, arrayruleids: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn DoesPropertyValueApply(&self, property: &::windows_core::BSTR, value: &::windows_core::BSTR, applyvalue: *mut super::super::Foundation::VARIANT_BOOL, idrule: &::windows_core::GUID, idpropdef: &::windows_core::GUID) -> ::windows_core::Result<()>; fn GetPropertyValueToApply(&self, property: &::windows_core::BSTR, value: *mut ::windows_core::BSTR, idrule: &::windows_core::GUID, idpropdef: &::windows_core::GUID) -> ::windows_core::Result<()>; fn OnEndFile(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmClassifierModuleImplementation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmClassifierModuleImplementation_Vtbl { pub const fn new, Impl: IFsrmClassifierModuleImplementation_Impl, const OFFSET: isize>() -> IFsrmClassifierModuleImplementation_Vtbl { - unsafe extern "system" fn LastModified, Impl: IFsrmClassifierModuleImplementation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastModified, Impl: IFsrmClassifierModuleImplementation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastModified() { @@ -1184,20 +1184,20 @@ impl IFsrmClassifierModuleImplementation_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmCollection_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; fn Cancel(&self) -> ::windows_core::Result<()>; fn WaitForCompletion(&self, waitseconds: i32) -> ::windows_core::Result; - fn GetById(&self, id: &::windows_core::GUID) -> ::windows_core::Result; + fn GetById(&self, id: &::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmCollection_Vtbl { pub const fn new, Impl: IFsrmCollection_Impl, const OFFSET: isize>() -> IFsrmCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFsrmCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1211,7 +1211,7 @@ impl IFsrmCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFsrmCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, item: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFsrmCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, item: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -1260,7 +1260,7 @@ impl IFsrmCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetById, Impl: IFsrmCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ::windows_core::GUID, entry: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetById, Impl: IFsrmCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: ::windows_core::GUID, entry: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetById(::core::mem::transmute(&id)) { @@ -1286,14 +1286,14 @@ impl IFsrmCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmCommittableCollection_Impl: Sized + IFsrmMutableCollection_Impl { fn Commit(&self, options: FsrmCommitOptions) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmCommittableCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmCommittableCollection_Vtbl { pub const fn new, Impl: IFsrmCommittableCollection_Impl, const OFFSET: isize>() -> IFsrmCommittableCollection_Vtbl { unsafe extern "system" fn Commit, Impl: IFsrmCommittableCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, options: FsrmCommitOptions, results: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1313,15 +1313,15 @@ impl IFsrmCommittableCollection_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmDerivedObjectsResult_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DerivedObjects(&self) -> ::windows_core::Result; fn Results(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmDerivedObjectsResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmDerivedObjectsResult_Vtbl { pub const fn new, Impl: IFsrmDerivedObjectsResult_Impl, const OFFSET: isize>() -> IFsrmDerivedObjectsResult_Vtbl { unsafe extern "system" fn DerivedObjects, Impl: IFsrmDerivedObjectsResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, derivedobjects: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1356,27 +1356,27 @@ impl IFsrmDerivedObjectsResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmExportImport_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn ExportFileGroups(&self, filepath: &::windows_core::BSTR, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ImportFileGroups(&self, filepath: &::windows_core::BSTR, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; - fn ExportFileScreenTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ImportFileScreenTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; - fn ExportQuotaTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ImportQuotaTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; + fn ExportFileGroups(&self, filepath: &::windows_core::BSTR, filegroupnamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn ImportFileGroups(&self, filepath: &::windows_core::BSTR, filegroupnamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; + fn ExportFileScreenTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn ImportFileScreenTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; + fn ExportQuotaTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn ImportQuotaTemplates(&self, filepath: &::windows_core::BSTR, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmExportImport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmExportImport_Vtbl { pub const fn new, Impl: IFsrmExportImport_Impl, const OFFSET: isize>() -> IFsrmExportImport_Vtbl { - unsafe extern "system" fn ExportFileGroups, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportFileGroups, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ExportFileGroups(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&filegroupnamessafearray), ::core::mem::transmute(&remotehost)).into() } - unsafe extern "system" fn ImportFileGroups, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportFileGroups, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportFileGroups(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&filegroupnamessafearray), ::core::mem::transmute(&remotehost)) { @@ -1387,12 +1387,12 @@ impl IFsrmExportImport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExportFileScreenTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportFileScreenTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ExportFileScreenTemplates(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&templatenamessafearray), ::core::mem::transmute(&remotehost)).into() } - unsafe extern "system" fn ImportFileScreenTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportFileScreenTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportFileScreenTemplates(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&templatenamessafearray), ::core::mem::transmute(&remotehost)) { @@ -1403,12 +1403,12 @@ impl IFsrmExportImport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExportQuotaTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportQuotaTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ExportQuotaTemplates(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&templatenamessafearray), ::core::mem::transmute(&remotehost)).into() } - unsafe extern "system" fn ImportQuotaTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportQuotaTemplates, Impl: IFsrmExportImport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportQuotaTemplates(::core::mem::transmute(&filepath), ::core::mem::transmute_copy(&templatenamessafearray), ::core::mem::transmute(&remotehost)) { @@ -1433,15 +1433,15 @@ impl IFsrmExportImport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileCondition_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileCondition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileCondition_Vtbl { pub const fn new, Impl: IFsrmFileCondition_Impl, const OFFSET: isize>() -> IFsrmFileCondition_Vtbl { unsafe extern "system" fn Type, Impl: IFsrmFileCondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut FsrmFileConditionType) -> ::windows_core::HRESULT { @@ -1470,8 +1470,8 @@ impl IFsrmFileCondition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileConditionProperty_Impl: Sized + IFsrmFileCondition_Impl { fn PropertyName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPropertyName(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1481,12 +1481,12 @@ pub trait IFsrmFileConditionProperty_Impl: Sized + IFsrmFileCondition_Impl { fn SetOperator(&self, newval: FsrmPropertyConditionType) -> ::windows_core::Result<()>; fn ValueType(&self) -> ::windows_core::Result; fn SetValueType(&self, newval: FsrmPropertyValueType) -> ::windows_core::Result<()>; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, newval: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileConditionProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileConditionProperty_Vtbl { pub const fn new, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>() -> IFsrmFileConditionProperty_Vtbl { unsafe extern "system" fn PropertyName, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1553,7 +1553,7 @@ impl IFsrmFileConditionProperty_Vtbl { let this = (*this).get_impl(); this.SetValueType(::core::mem::transmute_copy(&newval)).into() } - unsafe extern "system" fn Value, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -1564,7 +1564,7 @@ impl IFsrmFileConditionProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IFsrmFileConditionProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&newval)).into() @@ -1587,8 +1587,8 @@ impl IFsrmFileConditionProperty_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileGroup_Impl: Sized + IFsrmObject_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1597,9 +1597,9 @@ pub trait IFsrmFileGroup_Impl: Sized + IFsrmObject_Impl { fn NonMembers(&self) -> ::windows_core::Result; fn SetNonMembers(&self, nonmembers: ::core::option::Option<&IFsrmMutableCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileGroup_Vtbl { pub const fn new, Impl: IFsrmFileGroup_Impl, const OFFSET: isize>() -> IFsrmFileGroup_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmFileGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1664,15 +1664,15 @@ impl IFsrmFileGroup_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileGroupImported_Impl: Sized + IFsrmFileGroup_Impl { fn OverwriteOnCommit(&self) -> ::windows_core::Result; fn SetOverwriteOnCommit(&self, overwrite: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileGroupImported {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileGroupImported_Vtbl { pub const fn new, Impl: IFsrmFileGroupImported_Impl, const OFFSET: isize>() -> IFsrmFileGroupImported_Vtbl { unsafe extern "system" fn OverwriteOnCommit, Impl: IFsrmFileGroupImported_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, overwrite: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1701,18 +1701,18 @@ impl IFsrmFileGroupImported_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileGroupManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateFileGroup(&self) -> ::windows_core::Result; fn GetFileGroup(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn EnumFileGroups(&self, options: FsrmEnumOptions) -> ::windows_core::Result; - fn ExportFileGroups(&self, filegroupnamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn ImportFileGroups(&self, serializedfilegroups: &::windows_core::BSTR, filegroupnamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn ExportFileGroups(&self, filegroupnamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn ImportFileGroups(&self, serializedfilegroups: &::windows_core::BSTR, filegroupnamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileGroupManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileGroupManager_Vtbl { pub const fn new, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>() -> IFsrmFileGroupManager_Vtbl { unsafe extern "system" fn CreateFileGroup, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filegroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1748,7 +1748,7 @@ impl IFsrmFileGroupManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExportFileGroups, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filegroupnamesarray: *const super::super::System::Variant::VARIANT, serializedfilegroups: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportFileGroups, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filegroupnamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedfilegroups: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExportFileGroups(::core::mem::transmute_copy(&filegroupnamesarray)) { @@ -1759,7 +1759,7 @@ impl IFsrmFileGroupManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ImportFileGroups, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedfilegroups: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamesarray: *const super::super::System::Variant::VARIANT, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportFileGroups, Impl: IFsrmFileGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedfilegroups: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportFileGroups(::core::mem::transmute(&serializedfilegroups), ::core::mem::transmute_copy(&filegroupnamesarray)) { @@ -1783,8 +1783,8 @@ impl IFsrmFileGroupManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileManagementJob_Impl: Sized + IFsrmObject_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1836,9 +1836,9 @@ pub trait IFsrmFileManagementJob_Impl: Sized + IFsrmObject_Impl { fn CreatePropertyCondition(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn CreateCustomAction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileManagementJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileManagementJob_Vtbl { pub const fn new, Impl: IFsrmFileManagementJob_Impl, const OFFSET: isize>() -> IFsrmFileManagementJob_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmFileManagementJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2311,8 +2311,8 @@ impl IFsrmFileManagementJob_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileManagementJobManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ActionVariables(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn ActionVariableDescriptions(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -2320,9 +2320,9 @@ pub trait IFsrmFileManagementJobManager_Impl: Sized + super::super::System::Com: fn CreateFileManagementJob(&self) -> ::windows_core::Result; fn GetFileManagementJob(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileManagementJobManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileManagementJobManager_Vtbl { pub const fn new, Impl: IFsrmFileManagementJobManager_Impl, const OFFSET: isize>() -> IFsrmFileManagementJobManager_Vtbl { unsafe extern "system" fn ActionVariables, Impl: IFsrmFileManagementJobManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, variables: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -2393,8 +2393,8 @@ impl IFsrmFileManagementJobManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreen_Impl: Sized + IFsrmFileScreenBase_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SourceTemplateName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2403,9 +2403,9 @@ pub trait IFsrmFileScreen_Impl: Sized + IFsrmFileScreenBase_Impl { fn UserAccount(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ApplyTemplate(&self, filescreentemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreen {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreen_Vtbl { pub const fn new, Impl: IFsrmFileScreen_Impl, const OFFSET: isize>() -> IFsrmFileScreen_Vtbl { unsafe extern "system" fn Path, Impl: IFsrmFileScreen_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2482,8 +2482,8 @@ impl IFsrmFileScreen_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenBase_Impl: Sized + IFsrmObject_Impl { fn BlockedFileGroups(&self) -> ::windows_core::Result; fn SetBlockedFileGroups(&self, blocklist: ::core::option::Option<&IFsrmMutableCollection>) -> ::windows_core::Result<()>; @@ -2492,9 +2492,9 @@ pub trait IFsrmFileScreenBase_Impl: Sized + IFsrmObject_Impl { fn CreateAction(&self, actiontype: FsrmActionType) -> ::windows_core::Result; fn EnumActions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenBase {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenBase_Vtbl { pub const fn new, Impl: IFsrmFileScreenBase_Impl, const OFFSET: isize>() -> IFsrmFileScreenBase_Vtbl { unsafe extern "system" fn BlockedFileGroups, Impl: IFsrmFileScreenBase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, blocklist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2565,16 +2565,16 @@ impl IFsrmFileScreenBase_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenException_Impl: Sized + IFsrmObject_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn AllowedFileGroups(&self) -> ::windows_core::Result; fn SetAllowedFileGroups(&self, allowlist: ::core::option::Option<&IFsrmMutableCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenException {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenException_Vtbl { pub const fn new, Impl: IFsrmFileScreenException_Impl, const OFFSET: isize>() -> IFsrmFileScreenException_Vtbl { unsafe extern "system" fn Path, Impl: IFsrmFileScreenException_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2615,8 +2615,8 @@ impl IFsrmFileScreenException_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ActionVariables(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn ActionVariableDescriptions(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -2628,9 +2628,9 @@ pub trait IFsrmFileScreenManager_Impl: Sized + super::super::System::Com::IDispa fn EnumFileScreenExceptions(&self, path: &::windows_core::BSTR, options: FsrmEnumOptions) -> ::windows_core::Result; fn CreateFileScreenCollection(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenManager_Vtbl { pub const fn new, Impl: IFsrmFileScreenManager_Impl, const OFFSET: isize>() -> IFsrmFileScreenManager_Vtbl { unsafe extern "system" fn ActionVariables, Impl: IFsrmFileScreenManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, variables: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -2749,17 +2749,17 @@ impl IFsrmFileScreenManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenTemplate_Impl: Sized + IFsrmFileScreenBase_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CopyTemplate(&self, filescreentemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CommitAndUpdateDerived(&self, commitoptions: FsrmCommitOptions, applyoptions: FsrmTemplateApplyOptions) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenTemplate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenTemplate_Vtbl { pub const fn new, Impl: IFsrmFileScreenTemplate_Impl, const OFFSET: isize>() -> IFsrmFileScreenTemplate_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmFileScreenTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2806,15 +2806,15 @@ impl IFsrmFileScreenTemplate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenTemplateImported_Impl: Sized + IFsrmFileScreenTemplate_Impl { fn OverwriteOnCommit(&self) -> ::windows_core::Result; fn SetOverwriteOnCommit(&self, overwrite: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenTemplateImported {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenTemplateImported_Vtbl { pub const fn new, Impl: IFsrmFileScreenTemplateImported_Impl, const OFFSET: isize>() -> IFsrmFileScreenTemplateImported_Vtbl { unsafe extern "system" fn OverwriteOnCommit, Impl: IFsrmFileScreenTemplateImported_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, overwrite: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2843,18 +2843,18 @@ impl IFsrmFileScreenTemplateImported_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmFileScreenTemplateManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateTemplate(&self) -> ::windows_core::Result; fn GetTemplate(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn EnumTemplates(&self, options: FsrmEnumOptions) -> ::windows_core::Result; - fn ExportTemplates(&self, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn ImportTemplates(&self, serializedfilescreentemplates: &::windows_core::BSTR, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn ExportTemplates(&self, filescreentemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn ImportTemplates(&self, serializedfilescreentemplates: &::windows_core::BSTR, filescreentemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmFileScreenTemplateManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmFileScreenTemplateManager_Vtbl { pub const fn new, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>() -> IFsrmFileScreenTemplateManager_Vtbl { unsafe extern "system" fn CreateTemplate, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filescreentemplate: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2890,7 +2890,7 @@ impl IFsrmFileScreenTemplateManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExportTemplates, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT, serializedfilescreentemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportTemplates, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filescreentemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedfilescreentemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExportTemplates(::core::mem::transmute_copy(&filescreentemplatenamesarray)) { @@ -2901,7 +2901,7 @@ impl IFsrmFileScreenTemplateManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ImportTemplates, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedfilescreentemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT, filescreentemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportTemplates, Impl: IFsrmFileScreenTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedfilescreentemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, filescreentemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, filescreentemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportTemplates(::core::mem::transmute(&serializedfilescreentemplates), ::core::mem::transmute_copy(&filescreentemplatenamesarray)) { @@ -2925,20 +2925,20 @@ impl IFsrmFileScreenTemplateManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmMutableCollection_Impl: Sized + IFsrmCollection_Impl { - fn Add(&self, item: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Add(&self, item: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn RemoveById(&self, id: &::windows_core::GUID) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmMutableCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmMutableCollection_Vtbl { pub const fn new, Impl: IFsrmMutableCollection_Impl, const OFFSET: isize>() -> IFsrmMutableCollection_Vtbl { - unsafe extern "system" fn Add, Impl: IFsrmMutableCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IFsrmMutableCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute(&item)).into() @@ -2976,8 +2976,8 @@ impl IFsrmMutableCollection_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmObject_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::GUID>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2985,9 +2985,9 @@ pub trait IFsrmObject_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Delete(&self) -> ::windows_core::Result<()>; fn Commit(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmObject_Vtbl { pub const fn new, Impl: IFsrmObject_Impl, const OFFSET: isize>() -> IFsrmObject_Vtbl { unsafe extern "system" fn Id, Impl: IFsrmObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -3040,14 +3040,14 @@ impl IFsrmObject_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPathMapper_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetSharePathsForLocalPath(&self, localpath: &::windows_core::BSTR) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPathMapper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPathMapper_Vtbl { pub const fn new, Impl: IFsrmPathMapper_Impl, const OFFSET: isize>() -> IFsrmPathMapper_Vtbl { unsafe extern "system" fn GetSharePathsForLocalPath, Impl: IFsrmPathMapper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, localpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, sharepaths: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -3070,8 +3070,8 @@ impl IFsrmPathMapper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPipelineModuleConnector_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ModuleImplementation(&self) -> ::windows_core::Result; fn ModuleName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3079,9 +3079,9 @@ pub trait IFsrmPipelineModuleConnector_Impl: Sized + super::super::System::Com:: fn HostingProcessPid(&self) -> ::windows_core::Result; fn Bind(&self, moduledefinition: ::core::option::Option<&IFsrmPipelineModuleDefinition>, moduleimplementation: ::core::option::Option<&IFsrmPipelineModuleImplementation>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPipelineModuleConnector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPipelineModuleConnector_Vtbl { pub const fn new, Impl: IFsrmPipelineModuleConnector_Impl, const OFFSET: isize>() -> IFsrmPipelineModuleConnector_Vtbl { unsafe extern "system" fn ModuleImplementation, Impl: IFsrmPipelineModuleConnector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pipelinemoduleimplementation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3146,8 +3146,8 @@ impl IFsrmPipelineModuleConnector_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPipelineModuleDefinition_Impl: Sized + IFsrmObject_Impl { fn ModuleClsid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetModuleClsid(&self, moduleclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3169,9 +3169,9 @@ pub trait IFsrmPipelineModuleDefinition_Impl: Sized + IFsrmObject_Impl { fn Parameters(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetParameters(&self, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPipelineModuleDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPipelineModuleDefinition_Vtbl { pub const fn new, Impl: IFsrmPipelineModuleDefinition_Impl, const OFFSET: isize>() -> IFsrmPipelineModuleDefinition_Vtbl { unsafe extern "system" fn ModuleClsid, Impl: IFsrmPipelineModuleDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, moduleclsid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3356,15 +3356,15 @@ impl IFsrmPipelineModuleDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPipelineModuleImplementation_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn OnLoad(&self, moduledefinition: ::core::option::Option<&IFsrmPipelineModuleDefinition>) -> ::windows_core::Result; fn OnUnload(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPipelineModuleImplementation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPipelineModuleImplementation_Vtbl { pub const fn new, Impl: IFsrmPipelineModuleImplementation_Impl, const OFFSET: isize>() -> IFsrmPipelineModuleImplementation_Vtbl { unsafe extern "system" fn OnLoad, Impl: IFsrmPipelineModuleImplementation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, moduledefinition: *mut ::core::ffi::c_void, moduleconnector: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3393,17 +3393,17 @@ impl IFsrmPipelineModuleImplementation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmProperty_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Sources(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn PropertyFlags(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmProperty_Vtbl { pub const fn new, Impl: IFsrmProperty_Impl, const OFFSET: isize>() -> IFsrmProperty_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3462,21 +3462,21 @@ impl IFsrmProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyBag_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RelativePath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn VolumeName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RelativeNamespaceRoot(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn VolumeIndex(&self) -> ::windows_core::Result; - fn FileId(&self) -> ::windows_core::Result; - fn ParentDirectoryId(&self) -> ::windows_core::Result; - fn Size(&self) -> ::windows_core::Result; - fn SizeAllocated(&self) -> ::windows_core::Result; - fn CreationTime(&self) -> ::windows_core::Result; - fn LastAccessTime(&self) -> ::windows_core::Result; - fn LastModificationTime(&self) -> ::windows_core::Result; + fn FileId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ParentDirectoryId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Size(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SizeAllocated(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CreationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn LastAccessTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn LastModificationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Attributes(&self) -> ::windows_core::Result; fn OwnerSid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FilePropertyNames(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -3485,11 +3485,11 @@ pub trait IFsrmPropertyBag_Impl: Sized + super::super::System::Com::IDispatch_Im fn GetFileProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn SetFileProperty(&self, name: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddMessage(&self, message: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result; + fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyBag {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyBag_Vtbl { pub const fn new, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>() -> IFsrmPropertyBag_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3547,7 +3547,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn FileId, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fileid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn FileId, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fileid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FileId() { @@ -3558,7 +3558,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ParentDirectoryId, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, parentdirectoryid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ParentDirectoryId, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, parentdirectoryid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ParentDirectoryId() { @@ -3569,7 +3569,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Size, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, size: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Size, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, size: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Size() { @@ -3580,7 +3580,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SizeAllocated, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sizeallocated: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SizeAllocated, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sizeallocated: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SizeAllocated() { @@ -3591,7 +3591,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreationTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, creationtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreationTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, creationtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreationTime() { @@ -3602,7 +3602,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LastAccessTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastaccesstime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastAccessTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastaccesstime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastAccessTime() { @@ -3613,7 +3613,7 @@ impl IFsrmPropertyBag_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LastModificationTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodificationtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastModificationTime, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodificationtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastModificationTime() { @@ -3700,7 +3700,7 @@ impl IFsrmPropertyBag_Vtbl { let this = (*this).get_impl(); this.AddMessage(::core::mem::transmute(&message)).into() } - unsafe extern "system" fn GetFileStreamInterface, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType, pstreaminterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFileStreamInterface, Impl: IFsrmPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType, pstreaminterface: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFileStreamInterface(::core::mem::transmute_copy(&accessmode), ::core::mem::transmute_copy(&interfacetype)) { @@ -3740,18 +3740,18 @@ impl IFsrmPropertyBag_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyBag2_Impl: Sized + IFsrmPropertyBag_Impl { - fn GetFieldValue(&self, field: FsrmPropertyBagField) -> ::windows_core::Result; + fn GetFieldValue(&self, field: FsrmPropertyBagField) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetUntrustedInFileProperties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyBag2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyBag2_Vtbl { pub const fn new, Impl: IFsrmPropertyBag2_Impl, const OFFSET: isize>() -> IFsrmPropertyBag2_Vtbl { - unsafe extern "system" fn GetFieldValue, Impl: IFsrmPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, field: FsrmPropertyBagField, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFieldValue, Impl: IFsrmPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, field: FsrmPropertyBagField, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFieldValue(::core::mem::transmute_copy(&field)) { @@ -3783,8 +3783,8 @@ impl IFsrmPropertyBag2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyCondition_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3794,9 +3794,9 @@ pub trait IFsrmPropertyCondition_Impl: Sized + super::super::System::Com::IDispa fn SetValue(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyCondition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyCondition_Vtbl { pub const fn new, Impl: IFsrmPropertyCondition_Impl, const OFFSET: isize>() -> IFsrmPropertyCondition_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmPropertyCondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3867,8 +3867,8 @@ impl IFsrmPropertyCondition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyDefinition_Impl: Sized + IFsrmObject_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3881,9 +3881,9 @@ pub trait IFsrmPropertyDefinition_Impl: Sized + IFsrmObject_Impl { fn Parameters(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetParameters(&self, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyDefinition_Vtbl { pub const fn new, Impl: IFsrmPropertyDefinition_Impl, const OFFSET: isize>() -> IFsrmPropertyDefinition_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmPropertyDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3984,8 +3984,8 @@ impl IFsrmPropertyDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyDefinition2_Impl: Sized + IFsrmPropertyDefinition_Impl { fn PropertyDefinitionFlags(&self) -> ::windows_core::Result; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3993,9 +3993,9 @@ pub trait IFsrmPropertyDefinition2_Impl: Sized + IFsrmPropertyDefinition_Impl { fn AppliesTo(&self) -> ::windows_core::Result; fn ValueDefinitions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyDefinition2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyDefinition2_Vtbl { pub const fn new, Impl: IFsrmPropertyDefinition2_Impl, const OFFSET: isize>() -> IFsrmPropertyDefinition2_Vtbl { unsafe extern "system" fn PropertyDefinitionFlags, Impl: IFsrmPropertyDefinition2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertydefinitionflags: *mut i32) -> ::windows_core::HRESULT { @@ -4060,17 +4060,17 @@ impl IFsrmPropertyDefinition2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmPropertyDefinitionValue_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UniqueID(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmPropertyDefinitionValue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmPropertyDefinitionValue_Vtbl { pub const fn new, Impl: IFsrmPropertyDefinitionValue_Impl, const OFFSET: isize>() -> IFsrmPropertyDefinitionValue_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmPropertyDefinitionValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4129,21 +4129,21 @@ impl IFsrmPropertyDefinitionValue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuota_Impl: Sized + IFsrmQuotaObject_Impl { - fn QuotaUsed(&self) -> ::windows_core::Result; - fn QuotaPeakUsage(&self) -> ::windows_core::Result; + fn QuotaUsed(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn QuotaPeakUsage(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn QuotaPeakUsageTime(&self) -> ::windows_core::Result; fn ResetPeakUsage(&self) -> ::windows_core::Result<()>; fn RefreshUsageProperties(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuota {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuota_Vtbl { pub const fn new, Impl: IFsrmQuota_Impl, const OFFSET: isize>() -> IFsrmQuota_Vtbl { - unsafe extern "system" fn QuotaUsed, Impl: IFsrmQuota_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, used: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QuotaUsed, Impl: IFsrmQuota_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, used: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.QuotaUsed() { @@ -4154,7 +4154,7 @@ impl IFsrmQuota_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn QuotaPeakUsage, Impl: IFsrmQuota_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peakusage: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QuotaPeakUsage, Impl: IFsrmQuota_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peakusage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.QuotaPeakUsage() { @@ -4199,11 +4199,11 @@ impl IFsrmQuota_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaBase_Impl: Sized + IFsrmObject_Impl { - fn QuotaLimit(&self) -> ::windows_core::Result; - fn SetQuotaLimit(&self, quotalimit: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetQuotaLimit(&self, quotalimit: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn QuotaFlags(&self) -> ::windows_core::Result; fn SetQuotaFlags(&self, quotaflags: i32) -> ::windows_core::Result<()>; fn Thresholds(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -4213,12 +4213,12 @@ pub trait IFsrmQuotaBase_Impl: Sized + IFsrmObject_Impl { fn CreateThresholdAction(&self, threshold: i32, actiontype: FsrmActionType) -> ::windows_core::Result; fn EnumThresholdActions(&self, threshold: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaBase {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaBase_Vtbl { pub const fn new, Impl: IFsrmQuotaBase_Impl, const OFFSET: isize>() -> IFsrmQuotaBase_Vtbl { - unsafe extern "system" fn QuotaLimit, Impl: IFsrmQuotaBase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotalimit: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QuotaLimit, Impl: IFsrmQuotaBase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotalimit: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.QuotaLimit() { @@ -4229,7 +4229,7 @@ impl IFsrmQuotaBase_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetQuotaLimit, Impl: IFsrmQuotaBase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetQuotaLimit, Impl: IFsrmQuotaBase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotalimit: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetQuotaLimit(::core::mem::transmute("alimit)).into() @@ -4316,8 +4316,8 @@ impl IFsrmQuotaBase_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ActionVariables(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn ActionVariableDescriptions(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -4332,9 +4332,9 @@ pub trait IFsrmQuotaManager_Impl: Sized + super::super::System::Com::IDispatch_I fn Scan(&self, strpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CreateQuotaCollection(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaManager_Vtbl { pub const fn new, Impl: IFsrmQuotaManager_Impl, const OFFSET: isize>() -> IFsrmQuotaManager_Vtbl { unsafe extern "system" fn ActionVariables, Impl: IFsrmQuotaManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, variables: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -4483,14 +4483,14 @@ impl IFsrmQuotaManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaManagerEx_Impl: Sized + IFsrmQuotaManager_Impl { fn IsAffectedByQuota(&self, path: &::windows_core::BSTR, options: FsrmEnumOptions) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaManagerEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaManagerEx_Vtbl { pub const fn new, Impl: IFsrmQuotaManagerEx_Impl, const OFFSET: isize>() -> IFsrmQuotaManagerEx_Vtbl { unsafe extern "system" fn IsAffectedByQuota, Impl: IFsrmQuotaManagerEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, options: FsrmEnumOptions, affected: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4510,8 +4510,8 @@ impl IFsrmQuotaManagerEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaObject_Impl: Sized + IFsrmQuotaBase_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserSid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4520,9 +4520,9 @@ pub trait IFsrmQuotaObject_Impl: Sized + IFsrmQuotaBase_Impl { fn MatchesSourceTemplate(&self) -> ::windows_core::Result; fn ApplyTemplate(&self, quotatemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaObject_Vtbl { pub const fn new, Impl: IFsrmQuotaObject_Impl, const OFFSET: isize>() -> IFsrmQuotaObject_Vtbl { unsafe extern "system" fn Path, Impl: IFsrmQuotaObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4599,17 +4599,17 @@ impl IFsrmQuotaObject_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaTemplate_Impl: Sized + IFsrmQuotaBase_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CopyTemplate(&self, quotatemplatename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn CommitAndUpdateDerived(&self, commitoptions: FsrmCommitOptions, applyoptions: FsrmTemplateApplyOptions) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaTemplate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaTemplate_Vtbl { pub const fn new, Impl: IFsrmQuotaTemplate_Impl, const OFFSET: isize>() -> IFsrmQuotaTemplate_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmQuotaTemplate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4656,15 +4656,15 @@ impl IFsrmQuotaTemplate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaTemplateImported_Impl: Sized + IFsrmQuotaTemplate_Impl { fn OverwriteOnCommit(&self) -> ::windows_core::Result; fn SetOverwriteOnCommit(&self, overwrite: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaTemplateImported {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaTemplateImported_Vtbl { pub const fn new, Impl: IFsrmQuotaTemplateImported_Impl, const OFFSET: isize>() -> IFsrmQuotaTemplateImported_Vtbl { unsafe extern "system" fn OverwriteOnCommit, Impl: IFsrmQuotaTemplateImported_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, overwrite: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4693,18 +4693,18 @@ impl IFsrmQuotaTemplateImported_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmQuotaTemplateManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateTemplate(&self) -> ::windows_core::Result; fn GetTemplate(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn EnumTemplates(&self, options: FsrmEnumOptions) -> ::windows_core::Result; - fn ExportTemplates(&self, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn ImportTemplates(&self, serializedquotatemplates: &::windows_core::BSTR, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn ExportTemplates(&self, quotatemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn ImportTemplates(&self, serializedquotatemplates: &::windows_core::BSTR, quotatemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmQuotaTemplateManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmQuotaTemplateManager_Vtbl { pub const fn new, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>() -> IFsrmQuotaTemplateManager_Vtbl { unsafe extern "system" fn CreateTemplate, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotatemplate: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4740,7 +4740,7 @@ impl IFsrmQuotaTemplateManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExportTemplates, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT, serializedquotatemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExportTemplates, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, quotatemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedquotatemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExportTemplates(::core::mem::transmute_copy("atemplatenamesarray)) { @@ -4751,7 +4751,7 @@ impl IFsrmQuotaTemplateManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ImportTemplates, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedquotatemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT, quotatemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportTemplates, Impl: IFsrmQuotaTemplateManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, serializedquotatemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, quotatemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, quotatemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ImportTemplates(::core::mem::transmute(&serializedquotatemplates), ::core::mem::transmute_copy("atemplatenamesarray)) { @@ -4775,8 +4775,8 @@ impl IFsrmQuotaTemplateManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmReport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4784,13 +4784,13 @@ pub trait IFsrmReport_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn LastGeneratedFileNamePrefix(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetFilter(&self, filter: FsrmReportFilter) -> ::windows_core::Result; - fn SetFilter(&self, filter: FsrmReportFilter, filtervalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetFilter(&self, filter: FsrmReportFilter) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetFilter(&self, filter: FsrmReportFilter, filtervalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmReport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmReport_Vtbl { pub const fn new, Impl: IFsrmReport_Impl, const OFFSET: isize>() -> IFsrmReport_Vtbl { unsafe extern "system" fn Type, Impl: IFsrmReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttype: *mut FsrmReportType) -> ::windows_core::HRESULT { @@ -4847,7 +4847,7 @@ impl IFsrmReport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetFilter, Impl: IFsrmReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFilter, Impl: IFsrmReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFilter(::core::mem::transmute_copy(&filter)) { @@ -4858,7 +4858,7 @@ impl IFsrmReport_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetFilter, Impl: IFsrmReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetFilter, Impl: IFsrmReport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetFilter(::core::mem::transmute_copy(&filter), ::core::mem::transmute(&filtervalue)).into() @@ -4885,8 +4885,8 @@ impl IFsrmReport_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmReportJob_Impl: Sized + IFsrmObject_Impl { fn Task(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTask(&self, taskname: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4906,9 +4906,9 @@ pub trait IFsrmReportJob_Impl: Sized + IFsrmObject_Impl { fn WaitForCompletion(&self, waitseconds: i32) -> ::windows_core::Result; fn Cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmReportJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmReportJob_Vtbl { pub const fn new, Impl: IFsrmReportJob_Impl, const OFFSET: isize>() -> IFsrmReportJob_Vtbl { unsafe extern "system" fn Task, Impl: IFsrmReportJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, taskname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5087,8 +5087,8 @@ impl IFsrmReportJob_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmReportManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EnumReportJobs(&self, options: FsrmEnumOptions) -> ::windows_core::Result; fn CreateReportJob(&self) -> ::windows_core::Result; @@ -5096,14 +5096,14 @@ pub trait IFsrmReportManager_Impl: Sized + super::super::System::Com::IDispatch_ fn GetOutputDirectory(&self, context: FsrmReportGenerationContext) -> ::windows_core::Result<::windows_core::BSTR>; fn SetOutputDirectory(&self, context: FsrmReportGenerationContext, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsFilterValidForReportType(&self, reporttype: FsrmReportType, filter: FsrmReportFilter) -> ::windows_core::Result; - fn GetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter) -> ::windows_core::Result; - fn SetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetReportSizeLimit(&self, limit: FsrmReportLimit) -> ::windows_core::Result; - fn SetReportSizeLimit(&self, limit: FsrmReportLimit, limitvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetReportSizeLimit(&self, limit: FsrmReportLimit) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetReportSizeLimit(&self, limit: FsrmReportLimit, limitvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmReportManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmReportManager_Vtbl { pub const fn new, Impl: IFsrmReportManager_Impl, const OFFSET: isize>() -> IFsrmReportManager_Vtbl { unsafe extern "system" fn EnumReportJobs, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, options: FsrmEnumOptions, reportjobs: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5166,7 +5166,7 @@ impl IFsrmReportManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDefaultFilter, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDefaultFilter, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDefaultFilter(::core::mem::transmute_copy(&reporttype), ::core::mem::transmute_copy(&filter)) { @@ -5177,12 +5177,12 @@ impl IFsrmReportManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDefaultFilter, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDefaultFilter, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDefaultFilter(::core::mem::transmute_copy(&reporttype), ::core::mem::transmute_copy(&filter), ::core::mem::transmute(&filtervalue)).into() } - unsafe extern "system" fn GetReportSizeLimit, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetReportSizeLimit, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetReportSizeLimit(::core::mem::transmute_copy(&limit)) { @@ -5193,7 +5193,7 @@ impl IFsrmReportManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetReportSizeLimit, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetReportSizeLimit, Impl: IFsrmReportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetReportSizeLimit(::core::mem::transmute_copy(&limit), ::core::mem::transmute(&limitvalue)).into() @@ -5216,30 +5216,30 @@ impl IFsrmReportManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmReportScheduler_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn VerifyNamespaces(&self, namespacessafearray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn CreateScheduleTask(&self, taskname: &::windows_core::BSTR, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ModifyScheduleTask(&self, taskname: &::windows_core::BSTR, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn VerifyNamespaces(&self, namespacessafearray: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn CreateScheduleTask(&self, taskname: &::windows_core::BSTR, namespacessafearray: *const ::windows_core::VARIANT, serializedtask: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn ModifyScheduleTask(&self, taskname: &::windows_core::BSTR, namespacessafearray: *const ::windows_core::VARIANT, serializedtask: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DeleteScheduleTask(&self, taskname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmReportScheduler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmReportScheduler_Vtbl { pub const fn new, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>() -> IFsrmReportScheduler_Vtbl { - unsafe extern "system" fn VerifyNamespaces, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespacessafearray: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn VerifyNamespaces, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.VerifyNamespaces(::core::mem::transmute_copy(&namespacessafearray)).into() } - unsafe extern "system" fn CreateScheduleTask, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateScheduleTask, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CreateScheduleTask(::core::mem::transmute(&taskname), ::core::mem::transmute_copy(&namespacessafearray), ::core::mem::transmute(&serializedtask)).into() } - unsafe extern "system" fn ModifyScheduleTask, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ModifyScheduleTask, Impl: IFsrmReportScheduler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ModifyScheduleTask(::core::mem::transmute(&taskname), ::core::mem::transmute_copy(&namespacessafearray), ::core::mem::transmute(&serializedtask)).into() @@ -5261,8 +5261,8 @@ impl IFsrmReportScheduler_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmRule_Impl: Sized + IFsrmObject_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5275,11 +5275,11 @@ pub trait IFsrmRule_Impl: Sized + IFsrmObject_Impl { fn SetRuleFlags(&self, ruleflags: i32) -> ::windows_core::Result<()>; fn Parameters(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetParameters(&self, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; - fn LastModified(&self) -> ::windows_core::Result; + fn LastModified(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmRule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmRule_Vtbl { pub const fn new, Impl: IFsrmRule_Impl, const OFFSET: isize>() -> IFsrmRule_Vtbl { unsafe extern "system" fn Name, Impl: IFsrmRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5373,7 +5373,7 @@ impl IFsrmRule_Vtbl { let this = (*this).get_impl(); this.SetParameters(::core::mem::transmute_copy(¶meters)).into() } - unsafe extern "system" fn LastModified, Impl: IFsrmRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastModified, Impl: IFsrmRule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lastmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastModified() { @@ -5404,8 +5404,8 @@ impl IFsrmRule_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmSetting_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SmtpServer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSmtpServer(&self, smtpserver: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -5421,9 +5421,9 @@ pub trait IFsrmSetting_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetActionRunLimitInterval(&self, actiontype: FsrmActionType, delaytimeminutes: i32) -> ::windows_core::Result<()>; fn GetActionRunLimitInterval(&self, actiontype: FsrmActionType) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmSetting {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmSetting_Vtbl { pub const fn new, Impl: IFsrmSetting_Impl, const OFFSET: isize>() -> IFsrmSetting_Vtbl { unsafe extern "system" fn SmtpServer, Impl: IFsrmSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, smtpserver: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5548,8 +5548,8 @@ impl IFsrmSetting_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmStorageModuleDefinition_Impl: Sized + IFsrmPipelineModuleDefinition_Impl { fn Capabilities(&self) -> ::windows_core::Result; fn SetCapabilities(&self, capabilities: FsrmStorageModuleCaps) -> ::windows_core::Result<()>; @@ -5558,9 +5558,9 @@ pub trait IFsrmStorageModuleDefinition_Impl: Sized + IFsrmPipelineModuleDefiniti fn UpdatesFileContent(&self) -> ::windows_core::Result; fn SetUpdatesFileContent(&self, updatesfilecontent: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmStorageModuleDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmStorageModuleDefinition_Vtbl { pub const fn new, Impl: IFsrmStorageModuleDefinition_Impl, const OFFSET: isize>() -> IFsrmStorageModuleDefinition_Vtbl { unsafe extern "system" fn Capabilities, Impl: IFsrmStorageModuleDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, capabilities: *mut FsrmStorageModuleCaps) -> ::windows_core::HRESULT { @@ -5625,16 +5625,16 @@ impl IFsrmStorageModuleDefinition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsrmStorageModuleImplementation_Impl: Sized + IFsrmPipelineModuleImplementation_Impl { fn UseDefinitions(&self, propertydefinitions: ::core::option::Option<&IFsrmCollection>) -> ::windows_core::Result<()>; fn LoadProperties(&self, propertybag: ::core::option::Option<&IFsrmPropertyBag>) -> ::windows_core::Result<()>; fn SaveProperties(&self, propertybag: ::core::option::Option<&IFsrmPropertyBag>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsrmStorageModuleImplementation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsrmStorageModuleImplementation_Vtbl { pub const fn new, Impl: IFsrmStorageModuleImplementation_Impl, const OFFSET: isize>() -> IFsrmStorageModuleImplementation_Vtbl { unsafe extern "system" fn UseDefinitions, Impl: IFsrmStorageModuleImplementation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertydefinitions: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/mod.rs b/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/mod.rs index cb5fabb865..8e19112e63 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/FileServerResourceManager/mod.rs @@ -588,16 +588,15 @@ impl IFsrmAutoApplyQuota { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1210,9 +1209,7 @@ impl IFsrmClassificationRule { pub unsafe fn SetParameters(&self, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetParameters)(::windows_core::Interface::as_raw(self), parameters).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastModified(&self) -> ::windows_core::Result { + pub unsafe fn LastModified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.LastModified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1460,9 +1457,7 @@ impl IFsrmClassifierModuleImplementation { pub unsafe fn OnUnload(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.OnUnload)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastModified(&self) -> ::windows_core::Result { + pub unsafe fn LastModified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastModified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1505,10 +1500,7 @@ impl IFsrmClassifierModuleImplementation { #[doc(hidden)] pub struct IFsrmClassifierModuleImplementation_Vtbl { pub base__: IFsrmPipelineModuleImplementation_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastModified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastModified: usize, + pub LastModified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub UseRulesAndDefinitions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rules: *mut ::core::ffi::c_void, propertydefinitions: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -1536,9 +1528,7 @@ impl IFsrmCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -1557,9 +1547,7 @@ impl IFsrmCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).WaitForCompletion)(::windows_core::Interface::as_raw(self), waitseconds, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetById)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(id), &mut result__).from_abi(result__) } @@ -1570,18 +1558,12 @@ impl IFsrmCollection { pub struct IFsrmCollection_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unknown: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, item: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, item: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, state: *mut FsrmCollectionState) -> ::windows_core::HRESULT, pub Cancel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub WaitForCompletion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, waitseconds: i32, completed: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetById: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ::windows_core::GUID, entry: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetById: usize, + pub GetById: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ::windows_core::GUID, entry: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1598,9 +1580,7 @@ impl IFsrmCommittableCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -1619,16 +1599,15 @@ impl IFsrmCommittableCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.WaitForCompletion)(::windows_core::Interface::as_raw(self), waitseconds, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetById)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(id), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, item: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(item)).ok() + pub unsafe fn Add(&self, item: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Add)(::windows_core::Interface::as_raw(self), item.into_param().abi()).ok() } pub unsafe fn Remove(&self, index: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Remove)(::windows_core::Interface::as_raw(self), index).ok() @@ -1708,62 +1687,56 @@ pub struct IFsrmDerivedObjectsResult_Vtbl { ::windows_core::imp::interface_hierarchy!(IFsrmExportImport, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IFsrmExportImport { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportFileGroups(&self, filepath: P0, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result<()> + pub unsafe fn ExportFileGroups(&self, filepath: P0, filegroupnamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ExportFileGroups)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), filegroupnamessafearray, remotehost.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).ExportFileGroups)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(filegroupnamessafearray), remotehost.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportFileGroups(&self, filepath: P0, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportFileGroups(&self, filepath: P0, filegroupnamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportFileGroups)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), filegroupnamessafearray, remotehost.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportFileGroups)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(filegroupnamessafearray), remotehost.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportFileScreenTemplates(&self, filepath: P0, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result<()> + pub unsafe fn ExportFileScreenTemplates(&self, filepath: P0, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ExportFileScreenTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), templatenamessafearray, remotehost.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).ExportFileScreenTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(templatenamessafearray), remotehost.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportFileScreenTemplates(&self, filepath: P0, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportFileScreenTemplates(&self, filepath: P0, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportFileScreenTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), templatenamessafearray, remotehost.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportFileScreenTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(templatenamessafearray), remotehost.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportQuotaTemplates(&self, filepath: P0, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result<()> + pub unsafe fn ExportQuotaTemplates(&self, filepath: P0, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ExportQuotaTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), templatenamessafearray, remotehost.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).ExportQuotaTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(templatenamessafearray), remotehost.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportQuotaTemplates(&self, filepath: P0, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: P1) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportQuotaTemplates(&self, filepath: P0, templatenamessafearray: *const ::windows_core::VARIANT, remotehost: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportQuotaTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), templatenamessafearray, remotehost.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportQuotaTemplates)(::windows_core::Interface::as_raw(self), filepath.into_param().abi(), ::core::mem::transmute(templatenamessafearray), remotehost.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -1771,29 +1744,20 @@ impl IFsrmExportImport { #[doc(hidden)] pub struct IFsrmExportImport_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportFileGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportFileGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportFileScreenTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportFileScreenTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportFileScreenTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportFileScreenTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportFileScreenTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportFileScreenTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportQuotaTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportQuotaTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportQuotaTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const super::super::System::Variant::VARIANT, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportQuotaTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportQuotaTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, templatenamessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, remotehost: ::std::mem::MaybeUninit<::windows_core::BSTR>, templates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportQuotaTemplates: usize, } #[cfg(feature = "Win32_System_Com")] @@ -1872,16 +1836,15 @@ impl IFsrmFileConditionProperty { pub unsafe fn SetValueType(&self, newval: FsrmPropertyValueType) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetValueType)(::windows_core::Interface::as_raw(self), newval).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, newval: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(newval)).ok() + pub unsafe fn SetValue(&self, newval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1897,14 +1860,8 @@ pub struct IFsrmFileConditionProperty_Vtbl { pub SetOperator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: FsrmPropertyConditionType) -> ::windows_core::HRESULT, pub ValueType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut FsrmPropertyValueType) -> ::windows_core::HRESULT, pub SetValueType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: FsrmPropertyValueType) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2120,20 +2077,18 @@ impl IFsrmFileGroupManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumFileGroups)(::windows_core::Interface::as_raw(self), options, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportFileGroups(&self, filegroupnamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn ExportFileGroups(&self, filegroupnamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ExportFileGroups)(::windows_core::Interface::as_raw(self), filegroupnamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ExportFileGroups)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(filegroupnamesarray), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportFileGroups(&self, serializedfilegroups: P0, filegroupnamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportFileGroups(&self, serializedfilegroups: P0, filegroupnamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportFileGroups)(::windows_core::Interface::as_raw(self), serializedfilegroups.into_param().abi(), filegroupnamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportFileGroups)(::windows_core::Interface::as_raw(self), serializedfilegroups.into_param().abi(), ::core::mem::transmute(filegroupnamesarray), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -2153,13 +2108,10 @@ pub struct IFsrmFileGroupManager_Vtbl { pub EnumFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: FsrmEnumOptions, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] EnumFileGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filegroupnamesarray: *const super::super::System::Variant::VARIANT, serializedfilegroups: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportFileGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedfilegroups: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamesarray: *const super::super::System::Variant::VARIANT, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filegroupnamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedfilegroups: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportFileGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedfilegroups: ::std::mem::MaybeUninit<::windows_core::BSTR>, filegroupnamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, filegroups: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportFileGroups: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3204,20 +3156,18 @@ impl IFsrmFileScreenTemplateManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumTemplates)(::windows_core::Interface::as_raw(self), options, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportTemplates(&self, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn ExportTemplates(&self, filescreentemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ExportTemplates)(::windows_core::Interface::as_raw(self), filescreentemplatenamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ExportTemplates)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(filescreentemplatenamesarray), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportTemplates(&self, serializedfilescreentemplates: P0, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportTemplates(&self, serializedfilescreentemplates: P0, filescreentemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportTemplates)(::windows_core::Interface::as_raw(self), serializedfilescreentemplates.into_param().abi(), filescreentemplatenamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportTemplates)(::windows_core::Interface::as_raw(self), serializedfilescreentemplates.into_param().abi(), ::core::mem::transmute(filescreentemplatenamesarray), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3237,13 +3187,10 @@ pub struct IFsrmFileScreenTemplateManager_Vtbl { pub EnumTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: FsrmEnumOptions, filescreentemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] EnumTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT, serializedfilescreentemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedfilescreentemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, filescreentemplatenamesarray: *const super::super::System::Variant::VARIANT, filescreentemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filescreentemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedfilescreentemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedfilescreentemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, filescreentemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, filescreentemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportTemplates: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3261,9 +3208,7 @@ impl IFsrmMutableCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -3282,16 +3227,15 @@ impl IFsrmMutableCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.WaitForCompletion)(::windows_core::Interface::as_raw(self), waitseconds, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetById(&self, id: ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetById)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(id), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, item: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(item)).ok() + pub unsafe fn Add(&self, item: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), item.into_param().abi()).ok() } pub unsafe fn Remove(&self, index: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index).ok() @@ -3311,10 +3255,7 @@ impl IFsrmMutableCollection { #[doc(hidden)] pub struct IFsrmMutableCollection_Vtbl { pub base__: IFsrmCollection_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32) -> ::windows_core::HRESULT, pub RemoveById: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: ::windows_core::GUID) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -3723,45 +3664,31 @@ impl IFsrmPropertyBag { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).VolumeIndex)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FileId(&self) -> ::windows_core::Result { + pub unsafe fn FileId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FileId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ParentDirectoryId(&self) -> ::windows_core::Result { + pub unsafe fn ParentDirectoryId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ParentDirectoryId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Size(&self) -> ::windows_core::Result { + pub unsafe fn Size(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Size)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SizeAllocated(&self) -> ::windows_core::Result { + pub unsafe fn SizeAllocated(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SizeAllocated)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreationTime(&self) -> ::windows_core::Result { + pub unsafe fn CreationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreationTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastAccessTime(&self) -> ::windows_core::Result { + pub unsafe fn LastAccessTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastAccessTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastModificationTime(&self) -> ::windows_core::Result { + pub unsafe fn LastModificationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastModificationTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3811,9 +3738,7 @@ impl IFsrmPropertyBag { { (::windows_core::Interface::vtable(self).AddMessage)(::windows_core::Interface::as_raw(self), message.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result { + pub unsafe fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFileStreamInterface)(::windows_core::Interface::as_raw(self), accessmode, interfacetype, &mut result__).from_abi(result__) } @@ -3828,34 +3753,13 @@ pub struct IFsrmPropertyBag_Vtbl { pub VolumeName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, volumename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RelativeNamespaceRoot: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, relativenamespaceroot: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub VolumeIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, volumeid: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FileId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fileid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FileId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ParentDirectoryId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, parentdirectoryid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ParentDirectoryId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Size: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, size: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Size: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SizeAllocated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sizeallocated: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SizeAllocated: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, creationtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreationTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastAccessTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastaccesstime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastAccessTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastModificationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodificationtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastModificationTime: usize, + pub FileId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fileid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ParentDirectoryId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, parentdirectoryid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Size: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, size: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SizeAllocated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sizeallocated: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CreationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, creationtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub LastAccessTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastaccesstime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub LastModificationTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodificationtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Attributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributes: *mut u32) -> ::windows_core::HRESULT, pub OwnerSid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ownersid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -3873,10 +3777,7 @@ pub struct IFsrmPropertyBag_Vtbl { GetFileProperty: usize, pub SetFileProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub AddMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, message: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFileStreamInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType, pstreaminterface: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFileStreamInterface: usize, + pub GetFileStreamInterface: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType, pstreaminterface: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3909,45 +3810,31 @@ impl IFsrmPropertyBag2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.VolumeIndex)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FileId(&self) -> ::windows_core::Result { + pub unsafe fn FileId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.FileId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ParentDirectoryId(&self) -> ::windows_core::Result { + pub unsafe fn ParentDirectoryId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ParentDirectoryId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Size(&self) -> ::windows_core::Result { + pub unsafe fn Size(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Size)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SizeAllocated(&self) -> ::windows_core::Result { + pub unsafe fn SizeAllocated(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SizeAllocated)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreationTime(&self) -> ::windows_core::Result { + pub unsafe fn CreationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CreationTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastAccessTime(&self) -> ::windows_core::Result { + pub unsafe fn LastAccessTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.LastAccessTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastModificationTime(&self) -> ::windows_core::Result { + pub unsafe fn LastModificationTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.LastModificationTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3997,15 +3884,11 @@ impl IFsrmPropertyBag2 { { (::windows_core::Interface::vtable(self).base__.AddMessage)(::windows_core::Interface::as_raw(self), message.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result { + pub unsafe fn GetFileStreamInterface(&self, accessmode: FsrmFileStreamingMode, interfacetype: FsrmFileStreamingInterfaceType) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetFileStreamInterface)(::windows_core::Interface::as_raw(self), accessmode, interfacetype, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFieldValue(&self, field: FsrmPropertyBagField) -> ::windows_core::Result { + pub unsafe fn GetFieldValue(&self, field: FsrmPropertyBagField) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFieldValue)(::windows_core::Interface::as_raw(self), field, &mut result__).from_abi(result__) } @@ -4021,10 +3904,7 @@ impl IFsrmPropertyBag2 { #[doc(hidden)] pub struct IFsrmPropertyBag2_Vtbl { pub base__: IFsrmPropertyBag_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFieldValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, field: FsrmPropertyBagField, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFieldValue: usize, + pub GetFieldValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, field: FsrmPropertyBagField, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetUntrustedInFileProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, props: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4390,16 +4270,15 @@ impl IFsrmQuota { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4461,15 +4340,11 @@ impl IFsrmQuota { { (::windows_core::Interface::vtable(self).base__.ApplyTemplate)(::windows_core::Interface::as_raw(self), quotatemplatename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaUsed(&self) -> ::windows_core::Result { + pub unsafe fn QuotaUsed(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QuotaUsed)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaPeakUsage(&self) -> ::windows_core::Result { + pub unsafe fn QuotaPeakUsage(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QuotaPeakUsage)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4489,14 +4364,8 @@ impl IFsrmQuota { #[doc(hidden)] pub struct IFsrmQuota_Vtbl { pub base__: IFsrmQuotaObject_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub QuotaUsed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, used: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - QuotaUsed: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub QuotaPeakUsage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, peakusage: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - QuotaPeakUsage: usize, + pub QuotaUsed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, used: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub QuotaPeakUsage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, peakusage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub QuotaPeakUsageTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, peakusagedatetime: *mut f64) -> ::windows_core::HRESULT, pub ResetPeakUsage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RefreshUsageProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4532,16 +4401,15 @@ impl IFsrmQuotaBase { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4583,14 +4451,8 @@ impl IFsrmQuotaBase { #[doc(hidden)] pub struct IFsrmQuotaBase_Vtbl { pub base__: IFsrmObject_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub QuotaLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotalimit: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - QuotaLimit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetQuotaLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetQuotaLimit: usize, + pub QuotaLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotalimit: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetQuotaLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotalimit: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub QuotaFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotaflags: *mut i32) -> ::windows_core::HRESULT, pub SetQuotaFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotaflags: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -4923,16 +4785,15 @@ impl IFsrmQuotaObject { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5038,16 +4899,15 @@ impl IFsrmQuotaTemplate { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5150,16 +5010,15 @@ impl IFsrmQuotaTemplateImported { pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.Commit)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result { + pub unsafe fn QuotaLimit(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.QuotaLimit)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetQuotaLimit(&self, quotalimit: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotalimit)).ok() + pub unsafe fn SetQuotaLimit(&self, quotalimit: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.SetQuotaLimit)(::windows_core::Interface::as_raw(self), quotalimit.into_param().abi()).ok() } pub unsafe fn QuotaFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5268,20 +5127,18 @@ impl IFsrmQuotaTemplateManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumTemplates)(::windows_core::Interface::as_raw(self), options, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExportTemplates(&self, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn ExportTemplates(&self, quotatemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ExportTemplates)(::windows_core::Interface::as_raw(self), quotatemplatenamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ExportTemplates)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(quotatemplatenamesarray), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportTemplates(&self, serializedquotatemplates: P0, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ImportTemplates(&self, serializedquotatemplates: P0, quotatemplatenamesarray: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ImportTemplates)(::windows_core::Interface::as_raw(self), serializedquotatemplates.into_param().abi(), quotatemplatenamesarray, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ImportTemplates)(::windows_core::Interface::as_raw(self), serializedquotatemplates.into_param().abi(), ::core::mem::transmute(quotatemplatenamesarray), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -5301,13 +5158,10 @@ pub struct IFsrmQuotaTemplateManager_Vtbl { pub EnumTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, options: FsrmEnumOptions, quotatemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] EnumTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT, serializedquotatemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExportTemplates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedquotatemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, quotatemplatenamesarray: *const super::super::System::Variant::VARIANT, quotatemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub ExportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, quotatemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedquotatemplates: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ImportTemplates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, serializedquotatemplates: ::std::mem::MaybeUninit<::windows_core::BSTR>, quotatemplatenamesarray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, quotatemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ImportTemplates: usize, } #[cfg(feature = "Win32_System_Com")] @@ -5349,16 +5203,15 @@ impl IFsrmReport { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastGeneratedFileNamePrefix)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFilter(&self, filter: FsrmReportFilter) -> ::windows_core::Result { + pub unsafe fn GetFilter(&self, filter: FsrmReportFilter) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFilter)(::windows_core::Interface::as_raw(self), filter, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetFilter(&self, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), filter, ::core::mem::transmute(filtervalue)).ok() + pub unsafe fn SetFilter(&self, filter: FsrmReportFilter, filtervalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetFilter)(::windows_core::Interface::as_raw(self), filter, filtervalue.into_param().abi()).ok() } pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -5375,14 +5228,8 @@ pub struct IFsrmReport_Vtbl { pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, description: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, description: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LastGeneratedFileNamePrefix: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prefix: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFilter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetFilter: usize, + pub GetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filter: FsrmReportFilter, filtervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5584,27 +5431,25 @@ impl IFsrmReportManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsFilterValidForReportType)(::windows_core::Interface::as_raw(self), reporttype, filter, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter) -> ::windows_core::Result { + pub unsafe fn GetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDefaultFilter)(::windows_core::Interface::as_raw(self), reporttype, filter, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDefaultFilter)(::windows_core::Interface::as_raw(self), reporttype, filter, ::core::mem::transmute(filtervalue)).ok() + pub unsafe fn SetDefaultFilter(&self, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDefaultFilter)(::windows_core::Interface::as_raw(self), reporttype, filter, filtervalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetReportSizeLimit(&self, limit: FsrmReportLimit) -> ::windows_core::Result { + pub unsafe fn GetReportSizeLimit(&self, limit: FsrmReportLimit) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetReportSizeLimit)(::windows_core::Interface::as_raw(self), limit, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetReportSizeLimit(&self, limit: FsrmReportLimit, limitvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetReportSizeLimit)(::windows_core::Interface::as_raw(self), limit, ::core::mem::transmute(limitvalue)).ok() + pub unsafe fn SetReportSizeLimit(&self, limit: FsrmReportLimit, limitvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetReportSizeLimit)(::windows_core::Interface::as_raw(self), limit, limitvalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5627,22 +5472,10 @@ pub struct IFsrmReportManager_Vtbl { pub GetOutputDirectory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: FsrmReportGenerationContext, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetOutputDirectory: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: FsrmReportGenerationContext, path: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsFilterValidForReportType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, valid: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDefaultFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDefaultFilter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDefaultFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDefaultFilter: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetReportSizeLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetReportSizeLimit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetReportSizeLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetReportSizeLimit: usize, + pub GetDefaultFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDefaultFilter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reporttype: FsrmReportType, filter: FsrmReportFilter, filtervalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetReportSizeLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetReportSizeLimit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, limit: FsrmReportLimit, limitvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5655,28 +5488,22 @@ pub struct IFsrmReportManager_Vtbl { ::windows_core::imp::interface_hierarchy!(IFsrmReportScheduler, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IFsrmReportScheduler { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VerifyNamespaces(&self, namespacessafearray: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).VerifyNamespaces)(::windows_core::Interface::as_raw(self), namespacessafearray).ok() + pub unsafe fn VerifyNamespaces(&self, namespacessafearray: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).VerifyNamespaces)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(namespacessafearray)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateScheduleTask(&self, taskname: P0, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: P1) -> ::windows_core::Result<()> + pub unsafe fn CreateScheduleTask(&self, taskname: P0, namespacessafearray: *const ::windows_core::VARIANT, serializedtask: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).CreateScheduleTask)(::windows_core::Interface::as_raw(self), taskname.into_param().abi(), namespacessafearray, serializedtask.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).CreateScheduleTask)(::windows_core::Interface::as_raw(self), taskname.into_param().abi(), ::core::mem::transmute(namespacessafearray), serializedtask.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ModifyScheduleTask(&self, taskname: P0, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: P1) -> ::windows_core::Result<()> + pub unsafe fn ModifyScheduleTask(&self, taskname: P0, namespacessafearray: *const ::windows_core::VARIANT, serializedtask: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ModifyScheduleTask)(::windows_core::Interface::as_raw(self), taskname.into_param().abi(), namespacessafearray, serializedtask.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).ModifyScheduleTask)(::windows_core::Interface::as_raw(self), taskname.into_param().abi(), ::core::mem::transmute(namespacessafearray), serializedtask.into_param().abi()).ok() } pub unsafe fn DeleteScheduleTask(&self, taskname: P0) -> ::windows_core::Result<()> where @@ -5690,18 +5517,9 @@ impl IFsrmReportScheduler { #[doc(hidden)] pub struct IFsrmReportScheduler_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VerifyNamespaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespacessafearray: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VerifyNamespaces: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateScheduleTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateScheduleTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ModifyScheduleTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const super::super::System::Variant::VARIANT, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ModifyScheduleTask: usize, + pub VerifyNamespaces: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CreateScheduleTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub ModifyScheduleTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespacessafearray: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, serializedtask: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub DeleteScheduleTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, taskname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -5788,9 +5606,7 @@ impl IFsrmRule { pub unsafe fn SetParameters(&self, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetParameters)(::windows_core::Interface::as_raw(self), parameters).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastModified(&self) -> ::windows_core::Result { + pub unsafe fn LastModified(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastModified)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5823,10 +5639,7 @@ pub struct IFsrmRule_Vtbl { pub SetParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, parameters: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SetParameters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastModified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodified: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastModified: usize, + pub LastModified: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lastmodified: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( diff --git a/crates/libs/windows/src/Windows/Win32/Storage/Imapi/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/Imapi/impl.rs index b2d1ed77df..0343899e06 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/Imapi/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/Imapi/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DDiscFormat2DataEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, progress: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DDiscFormat2DataEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DDiscFormat2DataEvents_Vtbl { pub const fn new, Impl: DDiscFormat2DataEvents_Impl, const OFFSET: isize>() -> DDiscFormat2DataEvents_Vtbl { unsafe extern "system" fn Update, Impl: DDiscFormat2DataEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, progress: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -19,14 +19,14 @@ impl DDiscFormat2DataEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DDiscFormat2EraseEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, elapsedseconds: i32, estimatedtotalseconds: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DDiscFormat2EraseEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DDiscFormat2EraseEvents_Vtbl { pub const fn new, Impl: DDiscFormat2EraseEvents_Impl, const OFFSET: isize>() -> DDiscFormat2EraseEvents_Vtbl { unsafe extern "system" fn Update, Impl: DDiscFormat2EraseEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, elapsedseconds: i32, estimatedtotalseconds: i32) -> ::windows_core::HRESULT { @@ -40,14 +40,14 @@ impl DDiscFormat2EraseEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DDiscFormat2RawCDEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, progress: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DDiscFormat2RawCDEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DDiscFormat2RawCDEvents_Vtbl { pub const fn new, Impl: DDiscFormat2RawCDEvents_Impl, const OFFSET: isize>() -> DDiscFormat2RawCDEvents_Vtbl { unsafe extern "system" fn Update, Impl: DDiscFormat2RawCDEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, progress: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -61,14 +61,14 @@ impl DDiscFormat2RawCDEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DDiscFormat2TrackAtOnceEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, progress: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DDiscFormat2TrackAtOnceEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DDiscFormat2TrackAtOnceEvents_Vtbl { pub const fn new, Impl: DDiscFormat2TrackAtOnceEvents_Impl, const OFFSET: isize>() -> DDiscFormat2TrackAtOnceEvents_Vtbl { unsafe extern "system" fn Update, Impl: DDiscFormat2TrackAtOnceEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, progress: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -82,15 +82,15 @@ impl DDiscFormat2TrackAtOnceEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DDiscMaster2Events_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn NotifyDeviceAdded(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, uniqueid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn NotifyDeviceRemoved(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, uniqueid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DDiscMaster2Events {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DDiscMaster2Events_Vtbl { pub const fn new, Impl: DDiscMaster2Events_Impl, const OFFSET: isize>() -> DDiscMaster2Events_Vtbl { unsafe extern "system" fn NotifyDeviceAdded, Impl: DDiscMaster2Events_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, uniqueid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -113,14 +113,14 @@ impl DDiscMaster2Events_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DFileSystemImageEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, currentfile: &::windows_core::BSTR, copiedsectors: i32, totalsectors: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DFileSystemImageEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DFileSystemImageEvents_Vtbl { pub const fn new, Impl: DFileSystemImageEvents_Impl, const OFFSET: isize>() -> DFileSystemImageEvents_Vtbl { unsafe extern "system" fn Update, Impl: DFileSystemImageEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, currentfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, copiedsectors: i32, totalsectors: i32) -> ::windows_core::HRESULT { @@ -134,14 +134,14 @@ impl DFileSystemImageEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DFileSystemImageImportEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn UpdateImport(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, filesystem: FsiFileSystems, currentitem: &::windows_core::BSTR, importeddirectoryitems: i32, totaldirectoryitems: i32, importedfileitems: i32, totalfileitems: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DFileSystemImageImportEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DFileSystemImageImportEvents_Vtbl { pub const fn new, Impl: DFileSystemImageImportEvents_Impl, const OFFSET: isize>() -> DFileSystemImageImportEvents_Vtbl { unsafe extern "system" fn UpdateImport, Impl: DFileSystemImageImportEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, filesystem: FsiFileSystems, currentitem: ::std::mem::MaybeUninit<::windows_core::BSTR>, importeddirectoryitems: i32, totaldirectoryitems: i32, importedfileitems: i32, totalfileitems: i32) -> ::windows_core::HRESULT { @@ -155,14 +155,14 @@ impl DFileSystemImageImportEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DWriteEngine2Events_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Update(&self, object: ::core::option::Option<&super::super::System::Com::IDispatch>, progress: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DWriteEngine2Events {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DWriteEngine2Events_Vtbl { pub const fn new, Impl: DWriteEngine2Events_Impl, const OFFSET: isize>() -> DWriteEngine2Events_Vtbl { unsafe extern "system" fn Update, Impl: DWriteEngine2Events_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, object: *mut ::core::ffi::c_void, progress: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -176,15 +176,15 @@ impl DWriteEngine2Events_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBlockRange_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartLba(&self) -> ::windows_core::Result; fn EndLba(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBlockRange {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBlockRange_Vtbl { pub const fn new, Impl: IBlockRange_Impl, const OFFSET: isize>() -> IBlockRange_Vtbl { unsafe extern "system" fn StartLba, Impl: IBlockRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -219,14 +219,14 @@ impl IBlockRange_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBlockRangeList_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn BlockRanges(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBlockRangeList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBlockRangeList_Vtbl { pub const fn new, Impl: IBlockRangeList_Impl, const OFFSET: isize>() -> IBlockRangeList_Vtbl { unsafe extern "system" fn BlockRanges, Impl: IBlockRangeList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -246,8 +246,8 @@ impl IBlockRangeList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBootOptions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn BootImage(&self) -> ::windows_core::Result; fn Manufacturer(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -259,9 +259,9 @@ pub trait IBootOptions_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ImageSize(&self) -> ::windows_core::Result; fn AssignBootImage(&self, newval: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBootOptions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBootOptions_Vtbl { pub const fn new, Impl: IBootOptions_Impl, const OFFSET: isize>() -> IBootOptions_Vtbl { unsafe extern "system" fn BootImage, Impl: IBootOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -389,8 +389,8 @@ impl IBurnVerification_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsRecorderSupported(&self, recorder: ::core::option::Option<&IDiscRecorder2>) -> ::windows_core::Result; fn IsCurrentMediaSupported(&self, recorder: ::core::option::Option<&IDiscRecorder2>) -> ::windows_core::Result; @@ -398,9 +398,9 @@ pub trait IDiscFormat2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MediaHeuristicallyBlank(&self) -> ::windows_core::Result; fn SupportedMediaTypes(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2_Vtbl { pub const fn new, Impl: IDiscFormat2_Impl, const OFFSET: isize>() -> IDiscFormat2_Vtbl { unsafe extern "system" fn IsRecorderSupported, Impl: IDiscFormat2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recorder: *mut ::core::ffi::c_void, value: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -471,8 +471,8 @@ impl IDiscFormat2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2Data_Impl: Sized + IDiscFormat2_Impl { fn SetRecorder(&self, value: ::core::option::Option<&IDiscRecorder2>) -> ::windows_core::Result<()>; fn Recorder(&self) -> ::windows_core::Result; @@ -507,9 +507,9 @@ pub trait IDiscFormat2Data_Impl: Sized + IDiscFormat2_Impl { fn CancelWrite(&self) -> ::windows_core::Result<()>; fn SetWriteSpeed(&self, requestedsectorspersecond: i32, rotationtypeispurecav: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2Data {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2Data_Vtbl { pub const fn new, Impl: IDiscFormat2Data_Impl, const OFFSET: isize>() -> IDiscFormat2Data_Vtbl { unsafe extern "system" fn SetRecorder, Impl: IDiscFormat2Data_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -844,17 +844,17 @@ impl IDiscFormat2Data_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2DataEventArgs_Impl: Sized + IWriteEngine2EventArgs_Impl { fn ElapsedTime(&self) -> ::windows_core::Result; fn RemainingTime(&self) -> ::windows_core::Result; fn TotalTime(&self) -> ::windows_core::Result; fn CurrentAction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2DataEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2DataEventArgs_Vtbl { pub const fn new, Impl: IDiscFormat2DataEventArgs_Impl, const OFFSET: isize>() -> IDiscFormat2DataEventArgs_Vtbl { unsafe extern "system" fn ElapsedTime, Impl: IDiscFormat2DataEventArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -913,8 +913,8 @@ impl IDiscFormat2DataEventArgs_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2Erase_Impl: Sized + IDiscFormat2_Impl { fn SetRecorder(&self, value: ::core::option::Option<&IDiscRecorder2>) -> ::windows_core::Result<()>; fn Recorder(&self) -> ::windows_core::Result; @@ -925,9 +925,9 @@ pub trait IDiscFormat2Erase_Impl: Sized + IDiscFormat2_Impl { fn ClientName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EraseMedia(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2Erase {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2Erase_Vtbl { pub const fn new, Impl: IDiscFormat2Erase_Impl, const OFFSET: isize>() -> IDiscFormat2Erase_Vtbl { unsafe extern "system" fn SetRecorder, Impl: IDiscFormat2Erase_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1010,8 +1010,8 @@ impl IDiscFormat2Erase_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2RawCD_Impl: Sized + IDiscFormat2_Impl { fn PrepareMedia(&self) -> ::windows_core::Result<()>; fn WriteMedia(&self, data: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; @@ -1038,9 +1038,9 @@ pub trait IDiscFormat2RawCD_Impl: Sized + IDiscFormat2_Impl { fn SupportedWriteSpeeds(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SupportedWriteSpeedDescriptors(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2RawCD {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2RawCD_Vtbl { pub const fn new, Impl: IDiscFormat2RawCD_Impl, const OFFSET: isize>() -> IDiscFormat2RawCD_Vtbl { unsafe extern "system" fn PrepareMedia, Impl: IDiscFormat2RawCD_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1279,16 +1279,16 @@ impl IDiscFormat2RawCD_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2RawCDEventArgs_Impl: Sized + IWriteEngine2EventArgs_Impl { fn CurrentAction(&self) -> ::windows_core::Result; fn ElapsedTime(&self) -> ::windows_core::Result; fn RemainingTime(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2RawCDEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2RawCDEventArgs_Vtbl { pub const fn new, Impl: IDiscFormat2RawCDEventArgs_Impl, const OFFSET: isize>() -> IDiscFormat2RawCDEventArgs_Vtbl { unsafe extern "system" fn CurrentAction, Impl: IDiscFormat2RawCDEventArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut IMAPI_FORMAT2_RAW_CD_WRITE_ACTION) -> ::windows_core::HRESULT { @@ -1335,8 +1335,8 @@ impl IDiscFormat2RawCDEventArgs_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2TrackAtOnce_Impl: Sized + IDiscFormat2_Impl { fn PrepareMedia(&self) -> ::windows_core::Result<()>; fn AddAudioTrack(&self, data: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; @@ -1364,9 +1364,9 @@ pub trait IDiscFormat2TrackAtOnce_Impl: Sized + IDiscFormat2_Impl { fn SupportedWriteSpeeds(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SupportedWriteSpeedDescriptors(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2TrackAtOnce {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2TrackAtOnce_Vtbl { pub const fn new, Impl: IDiscFormat2TrackAtOnce_Impl, const OFFSET: isize>() -> IDiscFormat2TrackAtOnce_Vtbl { unsafe extern "system" fn PrepareMedia, Impl: IDiscFormat2TrackAtOnce_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1623,17 +1623,17 @@ impl IDiscFormat2TrackAtOnce_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscFormat2TrackAtOnceEventArgs_Impl: Sized + IWriteEngine2EventArgs_Impl { fn CurrentTrackNumber(&self) -> ::windows_core::Result; fn CurrentAction(&self) -> ::windows_core::Result; fn ElapsedTime(&self) -> ::windows_core::Result; fn RemainingTime(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscFormat2TrackAtOnceEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscFormat2TrackAtOnceEventArgs_Vtbl { pub const fn new, Impl: IDiscFormat2TrackAtOnceEventArgs_Impl, const OFFSET: isize>() -> IDiscFormat2TrackAtOnceEventArgs_Vtbl { unsafe extern "system" fn CurrentTrackNumber, Impl: IDiscFormat2TrackAtOnceEventArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -1819,17 +1819,17 @@ impl IDiscMaster_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IDiscMaster2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn Count(&self) -> ::windows_core::Result; fn IsSupportedEnvironment(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IDiscMaster2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IDiscMaster2_Vtbl { pub const fn new, Impl: IDiscMaster2_Impl, const OFFSET: isize>() -> IDiscMaster2_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IDiscMaster2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2122,8 +2122,8 @@ impl IDiscRecorder_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDiscRecorder2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn EjectMedia(&self) -> ::windows_core::Result<()>; fn CloseTray(&self) -> ::windows_core::Result<()>; @@ -2147,9 +2147,9 @@ pub trait IDiscRecorder2_Impl: Sized + super::super::System::Com::IDispatch_Impl fn SupportedModePages(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn ExclusiveAccessOwner(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDiscRecorder2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDiscRecorder2_Vtbl { pub const fn new, Impl: IDiscRecorder2_Impl, const OFFSET: isize>() -> IDiscRecorder2_Vtbl { unsafe extern "system" fn EjectMedia, Impl: IDiscRecorder2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2723,8 +2723,8 @@ impl IEnumProgressItems_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSystemImage_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Root(&self) -> ::windows_core::Result; fn SessionStartBlock(&self) -> ::windows_core::Result; @@ -2777,9 +2777,9 @@ pub trait IFileSystemImage_Impl: Sized + super::super::System::Com::IDispatch_Im fn MultisessionInterfaces(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetMultisessionInterfaces(&self, newval: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSystemImage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSystemImage_Vtbl { pub const fn new, Impl: IFileSystemImage_Impl, const OFFSET: isize>() -> IFileSystemImage_Vtbl { unsafe extern "system" fn Root, Impl: IFileSystemImage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3282,15 +3282,15 @@ impl IFileSystemImage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSystemImage2_Impl: Sized + IFileSystemImage_Impl { fn BootImageOptionsArray(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn SetBootImageOptionsArray(&self, newval: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSystemImage2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSystemImage2_Vtbl { pub const fn new, Impl: IFileSystemImage2_Impl, const OFFSET: isize>() -> IFileSystemImage2_Vtbl { unsafe extern "system" fn BootImageOptionsArray, Impl: IFileSystemImage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -3319,16 +3319,16 @@ impl IFileSystemImage2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSystemImage3_Impl: Sized + IFileSystemImage2_Impl { fn CreateRedundantUdfMetadataFiles(&self) -> ::windows_core::Result; fn SetCreateRedundantUdfMetadataFiles(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ProbeSpecificFileSystem(&self, filesystemtoprobe: FsiFileSystems) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSystemImage3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSystemImage3_Vtbl { pub const fn new, Impl: IFileSystemImage3_Impl, const OFFSET: isize>() -> IFileSystemImage3_Vtbl { unsafe extern "system" fn CreateRedundantUdfMetadataFiles, Impl: IFileSystemImage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3369,8 +3369,8 @@ impl IFileSystemImage3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSystemImageResult_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ImageStream(&self) -> ::windows_core::Result; fn ProgressItems(&self) -> ::windows_core::Result; @@ -3378,9 +3378,9 @@ pub trait IFileSystemImageResult_Impl: Sized + super::super::System::Com::IDispa fn BlockSize(&self) -> ::windows_core::Result; fn DiscId(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSystemImageResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSystemImageResult_Vtbl { pub const fn new, Impl: IFileSystemImageResult_Impl, const OFFSET: isize>() -> IFileSystemImageResult_Vtbl { unsafe extern "system" fn ImageStream, Impl: IFileSystemImageResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3451,14 +3451,14 @@ impl IFileSystemImageResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSystemImageResult2_Impl: Sized + IFileSystemImageResult_Impl { fn ModifiedBlocks(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSystemImageResult2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSystemImageResult2_Vtbl { pub const fn new, Impl: IFileSystemImageResult2_Impl, const OFFSET: isize>() -> IFileSystemImageResult2_Vtbl { unsafe extern "system" fn ModifiedBlocks, Impl: IFileSystemImageResult2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3478,8 +3478,8 @@ impl IFileSystemImageResult2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IFsiDirectoryItem_Impl: Sized + IFsiItem_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn get_Item(&self, path: &::windows_core::BSTR) -> ::windows_core::Result; @@ -3492,9 +3492,9 @@ pub trait IFsiDirectoryItem_Impl: Sized + IFsiItem_Impl { fn Remove(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RemoveTree(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IFsiDirectoryItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IFsiDirectoryItem_Vtbl { pub const fn new, Impl: IFsiDirectoryItem_Impl, const OFFSET: isize>() -> IFsiDirectoryItem_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFsiDirectoryItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3589,14 +3589,14 @@ impl IFsiDirectoryItem_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IFsiDirectoryItem2_Impl: Sized + IFsiDirectoryItem_Impl { fn AddTreeWithNamedStreams(&self, sourcedirectory: &::windows_core::BSTR, includebasedirectory: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IFsiDirectoryItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IFsiDirectoryItem2_Vtbl { pub const fn new, Impl: IFsiDirectoryItem2_Impl, const OFFSET: isize>() -> IFsiDirectoryItem2_Vtbl { unsafe extern "system" fn AddTreeWithNamedStreams, Impl: IFsiDirectoryItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sourcedirectory: ::std::mem::MaybeUninit<::windows_core::BSTR>, includebasedirectory: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3610,8 +3610,8 @@ impl IFsiDirectoryItem2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsiFileItem_Impl: Sized + IFsiItem_Impl { fn DataSize(&self) -> ::windows_core::Result; fn DataSize32BitLow(&self) -> ::windows_core::Result; @@ -3619,9 +3619,9 @@ pub trait IFsiFileItem_Impl: Sized + IFsiItem_Impl { fn Data(&self) -> ::windows_core::Result; fn SetData(&self, newval: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsiFileItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsiFileItem_Vtbl { pub const fn new, Impl: IFsiFileItem_Impl, const OFFSET: isize>() -> IFsiFileItem_Vtbl { unsafe extern "system" fn DataSize, Impl: IFsiFileItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i64) -> ::windows_core::HRESULT { @@ -3686,8 +3686,8 @@ impl IFsiFileItem_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsiFileItem2_Impl: Sized + IFsiFileItem_Impl { fn FsiNamedStreams(&self) -> ::windows_core::Result; fn IsNamedStream(&self) -> ::windows_core::Result; @@ -3696,9 +3696,9 @@ pub trait IFsiFileItem2_Impl: Sized + IFsiFileItem_Impl { fn IsRealTime(&self) -> ::windows_core::Result; fn SetIsRealTime(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsiFileItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsiFileItem2_Vtbl { pub const fn new, Impl: IFsiFileItem2_Impl, const OFFSET: isize>() -> IFsiFileItem2_Vtbl { unsafe extern "system" fn FsiNamedStreams, Impl: IFsiFileItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, streams: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3763,8 +3763,8 @@ impl IFsiFileItem2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFsiItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FullPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3779,9 +3779,9 @@ pub trait IFsiItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FileSystemName(&self, filesystem: FsiFileSystems) -> ::windows_core::Result<::windows_core::BSTR>; fn FileSystemPath(&self, filesystem: FsiFileSystems) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFsiItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFsiItem_Vtbl { pub const fn new, Impl: IFsiItem_Impl, const OFFSET: isize>() -> IFsiItem_Vtbl { unsafe extern "system" fn Name, Impl: IFsiItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3912,17 +3912,17 @@ impl IFsiItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IFsiNamedStreams_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn get_Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn EnumNamedStreams(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IFsiNamedStreams {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IFsiNamedStreams_Vtbl { pub const fn new, Impl: IFsiNamedStreams_Impl, const OFFSET: isize>() -> IFsiNamedStreams_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IFsiNamedStreams_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3981,8 +3981,8 @@ impl IFsiNamedStreams_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIsoImageManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Stream(&self) -> ::windows_core::Result; @@ -3990,9 +3990,9 @@ pub trait IIsoImageManager_Impl: Sized + super::super::System::Com::IDispatch_Im fn SetStream(&self, data: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result<()>; fn Validate(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIsoImageManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIsoImageManager_Vtbl { pub const fn new, Impl: IIsoImageManager_Impl, const OFFSET: isize>() -> IIsoImageManager_Vtbl { unsafe extern "system" fn Path, Impl: IIsoImageManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4128,17 +4128,17 @@ impl IJolietDiscMaster_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMultisession_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsSupportedOnCurrentMediaState(&self) -> ::windows_core::Result; fn SetInUse(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn InUse(&self) -> ::windows_core::Result; fn ImportRecorder(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMultisession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMultisession_Vtbl { pub const fn new, Impl: IMultisession_Impl, const OFFSET: isize>() -> IMultisession_Vtbl { unsafe extern "system" fn IsSupportedOnCurrentMediaState, Impl: IMultisession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4191,16 +4191,16 @@ impl IMultisession_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMultisessionRandomWrite_Impl: Sized + IMultisession_Impl { fn WriteUnitSize(&self) -> ::windows_core::Result; fn LastWrittenAddress(&self) -> ::windows_core::Result; fn TotalSectorsOnMedia(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMultisessionRandomWrite {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMultisessionRandomWrite_Vtbl { pub const fn new, Impl: IMultisessionRandomWrite_Impl, const OFFSET: isize>() -> IMultisessionRandomWrite_Vtbl { unsafe extern "system" fn WriteUnitSize, Impl: IMultisessionRandomWrite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -4247,8 +4247,8 @@ impl IMultisessionRandomWrite_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMultisessionSequential_Impl: Sized + IMultisession_Impl { fn IsFirstDataSession(&self) -> ::windows_core::Result; fn StartAddressOfPreviousSession(&self) -> ::windows_core::Result; @@ -4256,9 +4256,9 @@ pub trait IMultisessionSequential_Impl: Sized + IMultisession_Impl { fn NextWritableAddress(&self) -> ::windows_core::Result; fn FreeSectorsOnMedia(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMultisessionSequential {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMultisessionSequential_Vtbl { pub const fn new, Impl: IMultisessionSequential_Impl, const OFFSET: isize>() -> IMultisessionSequential_Vtbl { unsafe extern "system" fn IsFirstDataSession, Impl: IMultisessionSequential_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4329,14 +4329,14 @@ impl IMultisessionSequential_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMultisessionSequential2_Impl: Sized + IMultisessionSequential_Impl { fn WriteUnitSize(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMultisessionSequential2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMultisessionSequential2_Vtbl { pub const fn new, Impl: IMultisessionSequential2_Impl, const OFFSET: isize>() -> IMultisessionSequential2_Vtbl { unsafe extern "system" fn WriteUnitSize, Impl: IMultisessionSequential2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -4356,17 +4356,17 @@ impl IMultisessionSequential2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IProgressItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FirstBlock(&self) -> ::windows_core::Result; fn LastBlock(&self) -> ::windows_core::Result; fn BlockCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IProgressItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IProgressItem_Vtbl { pub const fn new, Impl: IProgressItem_Impl, const OFFSET: isize>() -> IProgressItem_Vtbl { unsafe extern "system" fn Description, Impl: IProgressItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, desc: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4425,8 +4425,8 @@ impl IProgressItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IProgressItems_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result; fn get_Item(&self, index: i32) -> ::windows_core::Result; @@ -4435,9 +4435,9 @@ pub trait IProgressItems_Impl: Sized + super::super::System::Com::IDispatch_Impl fn ProgressItemFromDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result; fn EnumProgressItems(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IProgressItems {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IProgressItems_Vtbl { pub const fn new, Impl: IProgressItems_Impl, const OFFSET: isize>() -> IProgressItems_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IProgressItems_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4520,8 +4520,8 @@ impl IProgressItems_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRawCDImageCreator_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn CreateResultImage(&self) -> ::windows_core::Result; fn AddTrack(&self, datatype: IMAPI_CD_SECTOR_TYPE, data: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result; @@ -4543,9 +4543,9 @@ pub trait IRawCDImageCreator_Impl: Sized + super::super::System::Com::IDispatch_ fn LastUsedUserSectorInImage(&self) -> ::windows_core::Result; fn ExpectedTableOfContents(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRawCDImageCreator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRawCDImageCreator_Vtbl { pub const fn new, Impl: IRawCDImageCreator_Impl, const OFFSET: isize>() -> IRawCDImageCreator_Vtbl { unsafe extern "system" fn CreateResultImage, Impl: IRawCDImageCreator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resultstream: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4742,8 +4742,8 @@ impl IRawCDImageCreator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRawCDImageTrackInfo_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartingLba(&self) -> ::windows_core::Result; fn SectorCount(&self) -> ::windows_core::Result; @@ -4759,9 +4759,9 @@ pub trait IRawCDImageTrackInfo_Impl: Sized + super::super::System::Com::IDispatc fn AddTrackIndex(&self, lbaoffset: i32) -> ::windows_core::Result<()>; fn ClearTrackIndex(&self, lbaoffset: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRawCDImageTrackInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRawCDImageTrackInfo_Vtbl { pub const fn new, Impl: IRawCDImageTrackInfo_Impl, const OFFSET: isize>() -> IRawCDImageTrackInfo_Vtbl { unsafe extern "system" fn StartingLba, Impl: IRawCDImageTrackInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -5114,8 +5114,8 @@ impl IStreamPseudoRandomBased_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWriteEngine2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn WriteSection(&self, data: ::core::option::Option<&super::super::System::Com::IStream>, startingblockaddress: i32, numberofblocks: i32) -> ::windows_core::Result<()>; fn CancelWrite(&self) -> ::windows_core::Result<()>; @@ -5131,9 +5131,9 @@ pub trait IWriteEngine2_Impl: Sized + super::super::System::Com::IDispatch_Impl fn BytesPerSector(&self) -> ::windows_core::Result; fn WriteInProgress(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWriteEngine2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWriteEngine2_Vtbl { pub const fn new, Impl: IWriteEngine2_Impl, const OFFSET: isize>() -> IWriteEngine2_Vtbl { unsafe extern "system" fn WriteSection, Impl: IWriteEngine2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: *mut ::core::ffi::c_void, startingblockaddress: i32, numberofblocks: i32) -> ::windows_core::HRESULT { @@ -5258,8 +5258,8 @@ impl IWriteEngine2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWriteEngine2EventArgs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn StartLba(&self) -> ::windows_core::Result; fn SectorCount(&self) -> ::windows_core::Result; @@ -5269,9 +5269,9 @@ pub trait IWriteEngine2EventArgs_Impl: Sized + super::super::System::Com::IDispa fn UsedSystemBuffer(&self) -> ::windows_core::Result; fn FreeSystemBuffer(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWriteEngine2EventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWriteEngine2EventArgs_Vtbl { pub const fn new, Impl: IWriteEngine2EventArgs_Impl, const OFFSET: isize>() -> IWriteEngine2EventArgs_Vtbl { unsafe extern "system" fn StartLba, Impl: IWriteEngine2EventArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut i32) -> ::windows_core::HRESULT { @@ -5366,16 +5366,16 @@ impl IWriteEngine2EventArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWriteSpeedDescriptor_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MediaType(&self) -> ::windows_core::Result; fn RotationTypeIsPureCAV(&self) -> ::windows_core::Result; fn WriteSpeed(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWriteSpeedDescriptor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWriteSpeedDescriptor_Vtbl { pub const fn new, Impl: IWriteSpeedDescriptor_Impl, const OFFSET: isize>() -> IWriteSpeedDescriptor_Vtbl { unsafe extern "system" fn MediaType, Impl: IWriteSpeedDescriptor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut IMAPI_MEDIA_PHYSICAL_TYPE) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/impl.rs index 7e1fb489f2..9e0eae81d8 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/impl.rs @@ -1,15 +1,15 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IFilter_Impl: Sized { fn Init(&self, grfflags: u32, cattributes: u32, aattributes: *const FULLPROPSPEC, pflags: *mut u32) -> i32; fn GetChunk(&self, pstat: *mut STAT_CHUNK) -> i32; fn GetText(&self, pcwcbuffer: *mut u32, awcbuffer: ::windows_core::PWSTR) -> i32; - fn GetValue(&self, pppropvalue: *mut *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> i32; + fn GetValue(&self, pppropvalue: *mut *mut ::windows_core::PROPVARIANT) -> i32; fn BindRegion(&self, origpos: &FILTERREGION, riid: *const ::windows_core::GUID, ppunk: *mut *mut ::core::ffi::c_void) -> i32; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IFilter {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IFilter_Vtbl { pub const fn new, Impl: IFilter_Impl, const OFFSET: isize>() -> IFilter_Vtbl { unsafe extern "system" fn Init, Impl: IFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grfflags: u32, cattributes: u32, aattributes: *const FULLPROPSPEC, pflags: *mut u32) -> i32 { @@ -27,7 +27,7 @@ impl IFilter_Vtbl { let this = (*this).get_impl(); this.GetText(::core::mem::transmute_copy(&pcwcbuffer), ::core::mem::transmute_copy(&awcbuffer)) } - unsafe extern "system" fn GetValue, Impl: IFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pppropvalue: *mut *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> i32 { + unsafe extern "system" fn GetValue, Impl: IFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pppropvalue: *mut *mut ::windows_core::PROPVARIANT) -> i32 { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValue(::core::mem::transmute_copy(&pppropvalue)) diff --git a/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/mod.rs b/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/mod.rs index 0cd51891f1..d51ef2c7f3 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/IndexServer/mod.rs @@ -53,9 +53,7 @@ impl IFilter { pub unsafe fn GetText(&self, pcwcbuffer: *mut u32, awcbuffer: ::windows_core::PWSTR) -> i32 { (::windows_core::Interface::vtable(self).GetText)(::windows_core::Interface::as_raw(self), pcwcbuffer, ::core::mem::transmute(awcbuffer)) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, pppropvalue: *mut *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> i32 { + pub unsafe fn GetValue(&self, pppropvalue: *mut *mut ::windows_core::PROPVARIANT) -> i32 { (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), pppropvalue) } pub unsafe fn BindRegion(&self, origpos: FILTERREGION, riid: *const ::windows_core::GUID, ppunk: *mut *mut ::core::ffi::c_void) -> i32 { @@ -75,10 +73,7 @@ pub struct IFilter_Vtbl { #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] GetChunk: usize, pub GetText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcwcbuffer: *mut u32, awcbuffer: ::windows_core::PWSTR) -> i32, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pppropvalue: *mut *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> i32, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pppropvalue: *mut *mut ::windows_core::PROPVARIANT) -> i32, pub BindRegion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, origpos: FILTERREGION, riid: *const ::windows_core::GUID, ppunk: *mut *mut ::core::ffi::c_void) -> i32, } ::windows_core::imp::com_interface!(IPhraseSink, IPhraseSink_Vtbl, 0xcc906ff0_c058_101a_b554_08002b33b0e6); diff --git a/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/impl.rs index e6d858c516..d1771332c2 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/impl.rs @@ -1240,22 +1240,18 @@ impl IOfflineFilesServerItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IOfflineFilesSetting_Impl: Sized { fn GetName(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetValueType(&self) -> ::windows_core::Result; - fn GetPreference(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; + fn GetPreference(&self, pvarvalue: *mut ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; fn GetPreferenceScope(&self) -> ::windows_core::Result; - fn SetPreference(&self, pvarvalue: *const super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; + fn SetPreference(&self, pvarvalue: *const ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; fn DeletePreference(&self, dwscope: u32) -> ::windows_core::Result<()>; - fn GetPolicy(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; + fn GetPolicy(&self, pvarvalue: *mut ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()>; fn GetPolicyScope(&self) -> ::windows_core::Result; - fn GetValue(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; + fn GetValue(&self, pvarvalue: *mut ::windows_core::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IOfflineFilesSetting {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IOfflineFilesSetting_Vtbl { pub const fn new, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>() -> IOfflineFilesSetting_Vtbl { unsafe extern "system" fn GetName, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -1280,7 +1276,7 @@ impl IOfflineFilesSetting_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPreference, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPreference, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPreference(::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&dwscope)).into() @@ -1296,7 +1292,7 @@ impl IOfflineFilesSetting_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPreference, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPreference, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPreference(::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&dwscope)).into() @@ -1306,7 +1302,7 @@ impl IOfflineFilesSetting_Vtbl { let this = (*this).get_impl(); this.DeletePreference(::core::mem::transmute_copy(&dwscope)).into() } - unsafe extern "system" fn GetPolicy, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPolicy, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPolicy(::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&dwscope)).into() @@ -1322,7 +1318,7 @@ impl IOfflineFilesSetting_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IOfflineFilesSetting_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValue(::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&pbsetbypolicy)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/mod.rs b/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/mod.rs index d7c6119ac8..739df2663b 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/OfflineFiles/mod.rs @@ -1523,36 +1523,28 @@ impl IOfflineFilesSetting { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValueType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPreference(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetPreference)(::windows_core::Interface::as_raw(self), pvarvalue, dwscope).ok() + pub unsafe fn GetPreference(&self, pvarvalue: *mut ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetPreference)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvalue), dwscope).ok() } pub unsafe fn GetPreferenceScope(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPreferenceScope)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPreference(&self, pvarvalue: *const super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPreference)(::windows_core::Interface::as_raw(self), pvarvalue, dwscope).ok() + pub unsafe fn SetPreference(&self, pvarvalue: *const ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetPreference)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvalue), dwscope).ok() } pub unsafe fn DeletePreference(&self, dwscope: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeletePreference)(::windows_core::Interface::as_raw(self), dwscope).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPolicy(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetPolicy)(::windows_core::Interface::as_raw(self), pvarvalue, dwscope).ok() + pub unsafe fn GetPolicy(&self, pvarvalue: *mut ::windows_core::VARIANT, dwscope: u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetPolicy)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvalue), dwscope).ok() } pub unsafe fn GetPolicyScope(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPolicyScope)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, pvarvalue: *mut super::super::System::Variant::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), pvarvalue, pbsetbypolicy).ok() + pub unsafe fn GetValue(&self, pvarvalue: *mut ::windows_core::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarvalue), pbsetbypolicy).ok() } } #[repr(C)] @@ -1561,25 +1553,13 @@ pub struct IOfflineFilesSetting_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GetValueType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptype: *mut OFFLINEFILES_SETTING_VALUE_TYPE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPreference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPreference: usize, + pub GetPreference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT, pub GetPreferenceScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwscope: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPreference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPreference: usize, + pub SetPreference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT, pub DeletePreference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwscope: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPolicy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, dwscope: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPolicy: usize, + pub GetPolicy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwscope: u32) -> ::windows_core::HRESULT, pub GetPolicyScope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwscope: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbsetbypolicy: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IOfflineFilesShareInfo, IOfflineFilesShareInfo_Vtbl, 0x7bcc43e7_31ce_4ca4_8ccd_1cff2dc494da); ::windows_core::imp::interface_hierarchy!(IOfflineFilesShareInfo, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/Storage/Vss/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/Vss/impl.rs index 840e428c82..4b07279702 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/Vss/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/Vss/impl.rs @@ -1018,8 +1018,6 @@ impl IVssExpressWriter_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IVssFileShareSnapshotProvider_Impl: Sized { fn SetContext(&self, lcontext: i32) -> ::windows_core::Result<()>; fn GetSnapshotProperties(&self, snapshotid: &::windows_core::GUID, pprop: *mut VSS_SNAPSHOT_PROP) -> ::windows_core::Result<()>; @@ -1028,11 +1026,9 @@ pub trait IVssFileShareSnapshotProvider_Impl: Sized { fn BeginPrepareSnapshot(&self, snapshotsetid: &::windows_core::GUID, snapshotid: &::windows_core::GUID, pwszsharepath: *const u16, lnewcontext: i32, providerid: &::windows_core::GUID) -> ::windows_core::Result<()>; fn IsPathSupported(&self, pwszsharepath: *const u16) -> ::windows_core::Result; fn IsPathSnapshotted(&self, pwszsharepath: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::Result<()>; - fn SetSnapshotProperty(&self, snapshotid: &::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSnapshotProperty(&self, snapshotid: &::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IVssFileShareSnapshotProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IVssFileShareSnapshotProvider_Vtbl { pub const fn new, Impl: IVssFileShareSnapshotProvider_Impl, const OFFSET: isize>() -> IVssFileShareSnapshotProvider_Vtbl { unsafe extern "system" fn SetContext, Impl: IVssFileShareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcontext: i32) -> ::windows_core::HRESULT { @@ -1082,7 +1078,7 @@ impl IVssFileShareSnapshotProvider_Vtbl { let this = (*this).get_impl(); this.IsPathSnapshotted(::core::mem::transmute_copy(&pwszsharepath), ::core::mem::transmute_copy(&pbsnapshotspresent), ::core::mem::transmute_copy(&plsnapshotcompatibility)).into() } - unsafe extern "system" fn SetSnapshotProperty, Impl: IVssFileShareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSnapshotProperty, Impl: IVssFileShareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSnapshotProperty(::core::mem::transmute(&snapshotid), ::core::mem::transmute_copy(&esnapshotpropertyid), ::core::mem::transmute(&vproperty)).into() @@ -1383,8 +1379,6 @@ impl IVssSnapshotMgmt2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IVssSoftwareSnapshotProvider_Impl: Sized { fn SetContext(&self, lcontext: i32) -> ::windows_core::Result<()>; fn GetSnapshotProperties(&self, snapshotid: &::windows_core::GUID, pprop: *mut VSS_SNAPSHOT_PROP) -> ::windows_core::Result<()>; @@ -1393,13 +1387,11 @@ pub trait IVssSoftwareSnapshotProvider_Impl: Sized { fn BeginPrepareSnapshot(&self, snapshotsetid: &::windows_core::GUID, snapshotid: &::windows_core::GUID, pwszvolumename: *const u16, lnewcontext: i32) -> ::windows_core::Result<()>; fn IsVolumeSupported(&self, pwszvolumename: *const u16) -> ::windows_core::Result; fn IsVolumeSnapshotted(&self, pwszvolumename: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::Result<()>; - fn SetSnapshotProperty(&self, snapshotid: &::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSnapshotProperty(&self, snapshotid: &::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RevertToSnapshot(&self, snapshotid: &::windows_core::GUID) -> ::windows_core::Result<()>; fn QueryRevertStatus(&self, pwszvolume: *const u16) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IVssSoftwareSnapshotProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IVssSoftwareSnapshotProvider_Vtbl { pub const fn new, Impl: IVssSoftwareSnapshotProvider_Impl, const OFFSET: isize>() -> IVssSoftwareSnapshotProvider_Vtbl { unsafe extern "system" fn SetContext, Impl: IVssSoftwareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcontext: i32) -> ::windows_core::HRESULT { @@ -1449,7 +1441,7 @@ impl IVssSoftwareSnapshotProvider_Vtbl { let this = (*this).get_impl(); this.IsVolumeSnapshotted(::core::mem::transmute_copy(&pwszvolumename), ::core::mem::transmute_copy(&pbsnapshotspresent), ::core::mem::transmute_copy(&plsnapshotcompatibility)).into() } - unsafe extern "system" fn SetSnapshotProperty, Impl: IVssSoftwareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSnapshotProperty, Impl: IVssSoftwareSnapshotProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSnapshotProperty(::core::mem::transmute(&snapshotid), ::core::mem::transmute_copy(&esnapshotpropertyid), ::core::mem::transmute(&vproperty)).into() diff --git a/crates/libs/windows/src/Windows/Win32/Storage/Vss/mod.rs b/crates/libs/windows/src/Windows/Win32/Storage/Vss/mod.rs index 56c4d69a41..11d57ef4b8 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/Vss/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/Vss/mod.rs @@ -1139,10 +1139,11 @@ impl IVssFileShareSnapshotProvider { pub unsafe fn IsPathSnapshotted(&self, pwszsharepath: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsPathSnapshotted)(::windows_core::Interface::as_raw(self), pwszsharepath, pbsnapshotspresent, plsnapshotcompatibility).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSnapshotProperty(&self, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSnapshotProperty)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(snapshotid), esnapshotpropertyid, ::core::mem::transmute(vproperty)).ok() + pub unsafe fn SetSnapshotProperty(&self, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSnapshotProperty)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(snapshotid), esnapshotpropertyid, vproperty.into_param().abi()).ok() } } #[repr(C)] @@ -1156,10 +1157,7 @@ pub struct IVssFileShareSnapshotProvider_Vtbl { pub BeginPrepareSnapshot: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotsetid: ::windows_core::GUID, snapshotid: ::windows_core::GUID, pwszsharepath: *const u16, lnewcontext: i32, providerid: ::windows_core::GUID) -> ::windows_core::HRESULT, pub IsPathSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszsharepath: *const u16, pbsupportedbythisprovider: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub IsPathSnapshotted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszsharepath: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSnapshotProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSnapshotProperty: usize, + pub SetSnapshotProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IVssHardwareSnapshotProvider, IVssHardwareSnapshotProvider_Vtbl, 0x9593a157_44e9_4344_bbeb_44fbf9b06b10); ::windows_core::imp::interface_hierarchy!(IVssHardwareSnapshotProvider, ::windows_core::IUnknown); @@ -1423,10 +1421,11 @@ impl IVssSoftwareSnapshotProvider { pub unsafe fn IsVolumeSnapshotted(&self, pwszvolumename: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IsVolumeSnapshotted)(::windows_core::Interface::as_raw(self), pwszvolumename, pbsnapshotspresent, plsnapshotcompatibility).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSnapshotProperty(&self, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSnapshotProperty)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(snapshotid), esnapshotpropertyid, ::core::mem::transmute(vproperty)).ok() + pub unsafe fn SetSnapshotProperty(&self, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSnapshotProperty)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(snapshotid), esnapshotpropertyid, vproperty.into_param().abi()).ok() } pub unsafe fn RevertToSnapshot(&self, snapshotid: ::windows_core::GUID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RevertToSnapshot)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(snapshotid)).ok() @@ -1447,10 +1446,7 @@ pub struct IVssSoftwareSnapshotProvider_Vtbl { pub BeginPrepareSnapshot: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotsetid: ::windows_core::GUID, snapshotid: ::windows_core::GUID, pwszvolumename: *const u16, lnewcontext: i32) -> ::windows_core::HRESULT, pub IsVolumeSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszvolumename: *const u16, pbsupportedbythisprovider: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub IsVolumeSnapshotted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszvolumename: *const u16, pbsnapshotspresent: *mut super::super::Foundation::BOOL, plsnapshotcompatibility: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSnapshotProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSnapshotProperty: usize, + pub SetSnapshotProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID, esnapshotpropertyid: VSS_SNAPSHOT_PROPERTY_ID, vproperty: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RevertToSnapshot: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapshotid: ::windows_core::GUID) -> ::windows_core::HRESULT, pub QueryRevertStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwszvolume: *const u16, ppasync: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/Storage/Xps/Printing/impl.rs b/crates/libs/windows/src/Windows/Win32/Storage/Xps/Printing/impl.rs index 09e8ab2aa2..144b57e006 100644 --- a/crates/libs/windows/src/Windows/Win32/Storage/Xps/Printing/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Storage/Xps/Printing/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrintDocumentPackageStatusEvent_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn PackageStatusUpdated(&self, packagestatus: *const PrintDocumentPackageStatus) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrintDocumentPackageStatusEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrintDocumentPackageStatusEvent_Vtbl { pub const fn new, Impl: IPrintDocumentPackageStatusEvent_Impl, const OFFSET: isize>() -> IPrintDocumentPackageStatusEvent_Vtbl { unsafe extern "system" fn PackageStatusUpdated, Impl: IPrintDocumentPackageStatusEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packagestatus: *const PrintDocumentPackageStatus) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/ApplicationInstallationAndServicing/impl.rs b/crates/libs/windows/src/Windows/Win32/System/ApplicationInstallationAndServicing/impl.rs index 3544b05848..d434216875 100644 --- a/crates/libs/windows/src/Windows/Win32/System/ApplicationInstallationAndServicing/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/ApplicationInstallationAndServicing/impl.rs @@ -321,16 +321,16 @@ impl IEnumMsmString_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmDependencies_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, item: i32) -> ::windows_core::Result; fn Count(&self, count: *mut i32) -> ::windows_core::Result<()>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmDependencies {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmDependencies_Vtbl { pub const fn new, Impl: IMsmDependencies_Impl, const OFFSET: isize>() -> IMsmDependencies_Vtbl { unsafe extern "system" fn get_Item, Impl: IMsmDependencies_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: i32, r#return: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -371,16 +371,16 @@ impl IMsmDependencies_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmDependency_Impl: Sized + super::Com::IDispatch_Impl { fn Module(&self, module: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn Language(&self, language: *mut i16) -> ::windows_core::Result<()>; fn Version(&self, version: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmDependency {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmDependency_Vtbl { pub const fn new, Impl: IMsmDependency_Impl, const OFFSET: isize>() -> IMsmDependency_Vtbl { unsafe extern "system" fn Module, Impl: IMsmDependency_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, module: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -409,8 +409,8 @@ impl IMsmDependency_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmError_Impl: Sized + super::Com::IDispatch_Impl { fn Type(&self, errortype: *mut msmErrorType) -> ::windows_core::Result<()>; fn Path(&self, errorpath: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -420,9 +420,9 @@ pub trait IMsmError_Impl: Sized + super::Com::IDispatch_Impl { fn ModuleTable(&self, errortable: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn ModuleKeys(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmError {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmError_Vtbl { pub const fn new, Impl: IMsmError_Impl, const OFFSET: isize>() -> IMsmError_Vtbl { unsafe extern "system" fn Type, Impl: IMsmError_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, errortype: *mut msmErrorType) -> ::windows_core::HRESULT { @@ -487,16 +487,16 @@ impl IMsmError_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmErrors_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, item: i32) -> ::windows_core::Result; fn Count(&self, count: *mut i32) -> ::windows_core::Result<()>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmErrors {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmErrors_Vtbl { pub const fn new, Impl: IMsmErrors_Impl, const OFFSET: isize>() -> IMsmErrors_Vtbl { unsafe extern "system" fn get_Item, Impl: IMsmErrors_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: i32, r#return: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -537,14 +537,14 @@ impl IMsmErrors_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmGetFiles_Impl: Sized + super::Com::IDispatch_Impl { fn ModuleFiles(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmGetFiles {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmGetFiles_Vtbl { pub const fn new, Impl: IMsmGetFiles_Impl, const OFFSET: isize>() -> IMsmGetFiles_Vtbl { unsafe extern "system" fn ModuleFiles, Impl: IMsmGetFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, files: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -564,8 +564,8 @@ impl IMsmGetFiles_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmMerge_Impl: Sized + super::Com::IDispatch_Impl { fn OpenDatabase(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn OpenModule(&self, path: &::windows_core::BSTR, language: i16) -> ::windows_core::Result<()>; @@ -581,9 +581,9 @@ pub trait IMsmMerge_Impl: Sized + super::Com::IDispatch_Impl { fn ExtractCAB(&self, filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ExtractFiles(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmMerge {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmMerge_Vtbl { pub const fn new, Impl: IMsmMerge_Impl, const OFFSET: isize>() -> IMsmMerge_Vtbl { unsafe extern "system" fn OpenDatabase, Impl: IMsmMerge_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -684,16 +684,16 @@ impl IMsmMerge_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMsmStrings_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, item: i32, r#return: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn Count(&self, count: *mut i32) -> ::windows_core::Result<()>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMsmStrings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMsmStrings_Vtbl { pub const fn new, Impl: IMsmStrings_Impl, const OFFSET: isize>() -> IMsmStrings_Vtbl { unsafe extern "system" fn get_Item, Impl: IMsmStrings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: i32, r#return: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/impl.rs b/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/impl.rs index 7edb1d0330..61b6aa1f12 100644 --- a/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Accessibility\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Accessibility"))] pub trait IAccessibleWinSAT_Impl: Sized + super::super::UI::Accessibility::IAccessible_Impl { fn SetAccessiblityData(&self, wsname: &::windows_core::PCWSTR, wsvalue: &::windows_core::PCWSTR, wsdesc: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Accessibility"))] impl ::windows_core::RuntimeName for IAccessibleWinSAT {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Accessibility"))] impl IAccessibleWinSAT_Vtbl { pub const fn new, Impl: IAccessibleWinSAT_Impl, const OFFSET: isize>() -> IAccessibleWinSAT_Vtbl { unsafe extern "system" fn SetAccessiblityData, Impl: IAccessibleWinSAT_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wsname: ::windows_core::PCWSTR, wsvalue: ::windows_core::PCWSTR, wsdesc: ::windows_core::PCWSTR) -> ::windows_core::HRESULT { @@ -56,16 +56,16 @@ impl IInitiateWinSATAssessment_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IProvideWinSATAssessmentInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Score(&self) -> ::windows_core::Result; fn Title(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IProvideWinSATAssessmentInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IProvideWinSATAssessmentInfo_Vtbl { pub const fn new, Impl: IProvideWinSATAssessmentInfo_Impl, const OFFSET: isize>() -> IProvideWinSATAssessmentInfo_Vtbl { unsafe extern "system" fn Score, Impl: IProvideWinSATAssessmentInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, score: *mut f32) -> ::windows_core::HRESULT { @@ -112,18 +112,18 @@ impl IProvideWinSATAssessmentInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IProvideWinSATResultsInfo_Impl: Sized + super::Com::IDispatch_Impl { fn GetAssessmentInfo(&self, assessment: WINSAT_ASSESSMENT_TYPE) -> ::windows_core::Result; fn AssessmentState(&self) -> ::windows_core::Result; - fn AssessmentDateTime(&self) -> ::windows_core::Result; + fn AssessmentDateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SystemRating(&self) -> ::windows_core::Result; fn RatingStateDesc(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IProvideWinSATResultsInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IProvideWinSATResultsInfo_Vtbl { pub const fn new, Impl: IProvideWinSATResultsInfo_Impl, const OFFSET: isize>() -> IProvideWinSATResultsInfo_Vtbl { unsafe extern "system" fn GetAssessmentInfo, Impl: IProvideWinSATResultsInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, assessment: WINSAT_ASSESSMENT_TYPE, ppinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -148,7 +148,7 @@ impl IProvideWinSATResultsInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AssessmentDateTime, Impl: IProvideWinSATResultsInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AssessmentDateTime, Impl: IProvideWinSATResultsInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, filetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AssessmentDateTime() { @@ -221,14 +221,14 @@ impl IProvideWinSATVisuals_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] pub trait IQueryAllWinSATAssessments_Impl: Sized + super::Com::IDispatch_Impl { fn get_AllXML(&self, xpath: &::windows_core::BSTR, namespaces: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IQueryAllWinSATAssessments {} -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl IQueryAllWinSATAssessments_Vtbl { pub const fn new, Impl: IQueryAllWinSATAssessments_Impl, const OFFSET: isize>() -> IQueryAllWinSATAssessments_Vtbl { unsafe extern "system" fn get_AllXML, Impl: IQueryAllWinSATAssessments_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaces: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppdomnodelist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -271,15 +271,15 @@ impl IQueryOEMWinSATCustomization_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] pub trait IQueryRecentWinSATAssessment_Impl: Sized + super::Com::IDispatch_Impl { fn get_XML(&self, xpath: &::windows_core::BSTR, namespaces: &::windows_core::BSTR) -> ::windows_core::Result; fn Info(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IQueryRecentWinSATAssessment {} -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl IQueryRecentWinSATAssessment_Vtbl { pub const fn new, Impl: IQueryRecentWinSATAssessment_Impl, const OFFSET: isize>() -> IQueryRecentWinSATAssessment_Vtbl { unsafe extern "system" fn get_XML, Impl: IQueryRecentWinSATAssessment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, namespaces: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppdomnodelist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/mod.rs b/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/mod.rs index 6e362b7c5e..6ddf485a16 100644 --- a/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/AssessmentTool/mod.rs @@ -21,119 +21,163 @@ impl IAccessibleWinSAT { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.accChildCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accChild(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Accessibility\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Accessibility"))] + pub unsafe fn get_accChild(&self, varchild: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accChild)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accChild)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accName(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accName(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accName)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accValue(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accValue(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accValue)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accDescription(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accDescription(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accDescription)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accRole(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accRole(&self, varchild: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accRole)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accRole)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accState(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accState(&self, varchild: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accState)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accState)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accHelp(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accHelp(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accHelp)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accHelp)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: super::Variant::VARIANT, pidtopic: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.get_accHelpTopic)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pszhelpfile), ::core::mem::transmute(varchild), pidtopic).ok() + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: P0, pidtopic: *mut i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.get_accHelpTopic)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pszhelpfile), varchild.into_param().abi(), pidtopic).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accKeyboardShortcut(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accKeyboardShortcut(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accKeyboardShortcut)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accKeyboardShortcut)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accFocus(&self) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accFocus(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.accFocus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accSelection(&self) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accSelection(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.accSelection)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn get_accDefaultAction(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn get_accDefaultAction(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.get_accDefaultAction)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.get_accDefaultAction)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accSelect(&self, flagsselect: i32, varchild: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.accSelect)(::windows_core::Interface::as_raw(self), flagsselect, ::core::mem::transmute(varchild)).ok() + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accSelect(&self, flagsselect: i32, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.accSelect)(::windows_core::Interface::as_raw(self), flagsselect, varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.accLocation)(::windows_core::Interface::as_raw(self), pxleft, pytop, pcxwidth, pcyheight, ::core::mem::transmute(varchild)).ok() + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.accLocation)(::windows_core::Interface::as_raw(self), pxleft, pytop, pcxwidth, pcyheight, varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accNavigate(&self, navdir: i32, varstart: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accNavigate(&self, navdir: i32, varstart: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.accNavigate)(::windows_core::Interface::as_raw(self), navdir, ::core::mem::transmute(varstart), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.accNavigate)(::windows_core::Interface::as_raw(self), navdir, varstart.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.accHitTest)(::windows_core::Interface::as_raw(self), xleft, ytop, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn accDoDefaultAction(&self, varchild: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.accDoDefaultAction)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild)).ok() + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn accDoDefaultAction(&self, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.accDoDefaultAction)(::windows_core::Interface::as_raw(self), varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn put_accName(&self, varchild: super::Variant::VARIANT, szname: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn put_accName(&self, varchild: P0, szname: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.put_accName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), szname.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.put_accName)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), szname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Accessibility\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Accessibility"))] - pub unsafe fn put_accValue(&self, varchild: super::Variant::VARIANT, szvalue: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_UI_Accessibility\"`"] + #[cfg(feature = "Win32_UI_Accessibility")] + pub unsafe fn put_accValue(&self, varchild: P0, szvalue: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.put_accValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), szvalue.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.put_accValue)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), szvalue.into_param().abi()).ok() } pub unsafe fn SetAccessiblityData(&self, wsname: P0, wsvalue: P1, wsdesc: P2) -> ::windows_core::Result<()> where @@ -235,9 +279,7 @@ impl IProvideWinSATResultsInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AssessmentState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AssessmentDateTime(&self) -> ::windows_core::Result { + pub unsafe fn AssessmentDateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AssessmentDateTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -260,10 +302,7 @@ pub struct IProvideWinSATResultsInfo_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] GetAssessmentInfo: usize, pub AssessmentState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, state: *mut WINSAT_ASSESSMENT_STATE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AssessmentDateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AssessmentDateTime: usize, + pub AssessmentDateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SystemRating: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, level: *mut f32) -> ::windows_core::HRESULT, pub RatingStateDesc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, description: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/System/ClrHosting/impl.rs b/crates/libs/windows/src/Windows/Win32/System/ClrHosting/impl.rs index fb26ca8657..7a5d518dbf 100644 --- a/crates/libs/windows/src/Windows/Win32/System/ClrHosting/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/ClrHosting/impl.rs @@ -3251,17 +3251,13 @@ impl IManagedObject_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IObjectHandle_Impl: Sized { - fn Unwrap(&self) -> ::windows_core::Result; + fn Unwrap(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IObjectHandle {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IObjectHandle_Vtbl { pub const fn new, Impl: IObjectHandle_Impl, const OFFSET: isize>() -> IObjectHandle_Vtbl { - unsafe extern "system" fn Unwrap, Impl: IObjectHandle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppv: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Unwrap, Impl: IObjectHandle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Unwrap() { diff --git a/crates/libs/windows/src/Windows/Win32/System/ClrHosting/mod.rs b/crates/libs/windows/src/Windows/Win32/System/ClrHosting/mod.rs index d92e8f0b52..f3eda3e3b5 100644 --- a/crates/libs/windows/src/Windows/Win32/System/ClrHosting/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/ClrHosting/mod.rs @@ -2416,9 +2416,7 @@ pub struct IManagedObject_Vtbl { ::windows_core::imp::com_interface!(IObjectHandle, IObjectHandle_Vtbl, 0xc460e2b4_e199_412a_8456_84dc3e4838c3); ::windows_core::imp::interface_hierarchy!(IObjectHandle, ::windows_core::IUnknown); impl IObjectHandle { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Unwrap(&self) -> ::windows_core::Result { + pub unsafe fn Unwrap(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Unwrap)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2427,10 +2425,7 @@ impl IObjectHandle { #[doc(hidden)] pub struct IObjectHandle_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Unwrap: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppv: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Unwrap: usize, + pub Unwrap: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITypeName, ITypeName_Vtbl, 0xb81ff171_20f3_11d2_8dcc_00a0c9b00522); ::windows_core::imp::interface_hierarchy!(ITypeName, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/impl.rs index dedd4808f5..80a56d6664 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/impl.rs @@ -1,5 +1,3 @@ -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ICallFrame_Impl: Sized { fn GetInfo(&self, pinfo: *mut CALLFRAMEINFO) -> ::windows_core::Result<()>; fn GetIIDAndMethod(&self, piid: *mut ::windows_core::GUID, pimethod: *mut u32) -> ::windows_core::Result<()>; @@ -9,8 +7,8 @@ pub trait ICallFrame_Impl: Sized { fn SetReturnValue(&self, hr: ::windows_core::HRESULT); fn GetReturnValue(&self) -> ::windows_core::Result<()>; fn GetParamInfo(&self, iparam: u32) -> ::windows_core::Result; - fn SetParam(&self, iparam: u32, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetParam(&self, iparam: u32) -> ::windows_core::Result; + fn SetParam(&self, iparam: u32, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetParam(&self, iparam: u32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Copy(&self, copycontrol: CALLFRAME_COPY, pwalker: ::core::option::Option<&ICallFrameWalker>) -> ::windows_core::Result; fn Free(&self, pframeargsdest: ::core::option::Option<&ICallFrame>, pwalkerdestfree: ::core::option::Option<&ICallFrameWalker>, pwalkercopy: ::core::option::Option<&ICallFrameWalker>, freeflags: u32, pwalkerfree: ::core::option::Option<&ICallFrameWalker>, nullflags: u32) -> ::windows_core::Result<()>; fn FreeParam(&self, iparam: u32, freeflags: u32, pwalkerfree: ::core::option::Option<&ICallFrameWalker>, nullflags: u32) -> ::windows_core::Result<()>; @@ -21,9 +19,7 @@ pub trait ICallFrame_Impl: Sized { fn ReleaseMarshalData(&self, pbuffer: *const ::core::ffi::c_void, cbbuffer: u32, ibfirstrelease: u32, datarep: u32, pcontext: *const CALLFRAME_MARSHALCONTEXT) -> ::windows_core::Result<()>; fn Invoke(&self, pvreceiver: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ICallFrame {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ICallFrame_Vtbl { pub const fn new, Impl: ICallFrame_Impl, const OFFSET: isize>() -> ICallFrame_Vtbl { unsafe extern "system" fn GetInfo, Impl: ICallFrame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pinfo: *mut CALLFRAMEINFO) -> ::windows_core::HRESULT { @@ -72,12 +68,12 @@ impl ICallFrame_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetParam, Impl: ICallFrame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParam, Impl: ICallFrame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParam(::core::mem::transmute_copy(&iparam), ::core::mem::transmute_copy(&pvar)).into() } - unsafe extern "system" fn GetParam, Impl: ICallFrame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParam, Impl: ICallFrame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParam(::core::mem::transmute_copy(&iparam)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/mod.rs index 9a1ddc472f..d2facc79ef 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/CallObj/mod.rs @@ -43,14 +43,10 @@ impl ICallFrame { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetParamInfo)(::windows_core::Interface::as_raw(self), iparam, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetParam(&self, iparam: u32, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetParam)(::windows_core::Interface::as_raw(self), iparam, pvar).ok() - } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParam(&self, iparam: u32) -> ::windows_core::Result { + pub unsafe fn SetParam(&self, iparam: u32, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetParam)(::windows_core::Interface::as_raw(self), iparam, ::core::mem::transmute(pvar)).ok() + } + pub unsafe fn GetParam(&self, iparam: u32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetParam)(::windows_core::Interface::as_raw(self), iparam, &mut result__).from_abi(result__) } @@ -112,14 +108,8 @@ pub struct ICallFrame_Vtbl { pub SetReturnValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hr: ::windows_core::HRESULT), pub GetReturnValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetParamInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, pinfo: *mut CALLFRAMEPARAMINFO) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetParam: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetParam: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParam: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParam: usize, + pub SetParam: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetParam: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Copy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, copycontrol: CALLFRAME_COPY, pwalker: *mut ::core::ffi::c_void, ppframe: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Free: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pframeargsdest: *mut ::core::ffi::c_void, pwalkerdestfree: *mut ::core::ffi::c_void, pwalkercopy: *mut ::core::ffi::c_void, freeflags: u32, pwalkerfree: *mut ::core::ffi::c_void, nullflags: u32) -> ::windows_core::HRESULT, pub FreeParam: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iparam: u32, freeflags: u32, pwalkerfree: *mut ::core::ffi::c_void, nullflags: u32) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/impl.rs index 210bc0021a..0df57e355e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/impl.rs @@ -1,20 +1,16 @@ -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IChannelCredentials_Impl: Sized + super::IDispatch_Impl { fn SetWindowsCredential(&self, domain: &::windows_core::BSTR, username: &::windows_core::BSTR, password: &::windows_core::BSTR, impersonationlevel: i32, allowntlm: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SetUserNameCredential(&self, username: &::windows_core::BSTR, password: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetClientCertificateFromStore(&self, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR, findyype: &::windows_core::BSTR, findvalue: &super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetClientCertificateFromStore(&self, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR, findyype: &::windows_core::BSTR, findvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetClientCertificateFromStoreByName(&self, subjectname: &::windows_core::BSTR, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetClientCertificateFromFile(&self, filename: &::windows_core::BSTR, password: &::windows_core::BSTR, keystorageflags: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetDefaultServiceCertificateFromStore(&self, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR, findtype: &::windows_core::BSTR, findvalue: &super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetDefaultServiceCertificateFromStore(&self, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR, findtype: &::windows_core::BSTR, findvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetDefaultServiceCertificateFromStoreByName(&self, subjectname: &::windows_core::BSTR, storelocation: &::windows_core::BSTR, storename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDefaultServiceCertificateFromFile(&self, filename: &::windows_core::BSTR, password: &::windows_core::BSTR, keystorageflags: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetServiceCertificateAuthentication(&self, storelocation: &::windows_core::BSTR, revocationmode: &::windows_core::BSTR, certificatevalidationmode: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetIssuedToken(&self, localissueraddres: &::windows_core::BSTR, localissuerbindingtype: &::windows_core::BSTR, localissuerbinding: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IChannelCredentials {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IChannelCredentials_Vtbl { pub const fn new, Impl: IChannelCredentials_Impl, const OFFSET: isize>() -> IChannelCredentials_Vtbl { unsafe extern "system" fn SetWindowsCredential, Impl: IChannelCredentials_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, domain: ::std::mem::MaybeUninit<::windows_core::BSTR>, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>, impersonationlevel: i32, allowntlm: super::super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -27,7 +23,7 @@ impl IChannelCredentials_Vtbl { let this = (*this).get_impl(); this.SetUserNameCredential(::core::mem::transmute(&username), ::core::mem::transmute(&password)).into() } - unsafe extern "system" fn SetClientCertificateFromStore, Impl: IChannelCredentials_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findyype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetClientCertificateFromStore, Impl: IChannelCredentials_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findyype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetClientCertificateFromStore(::core::mem::transmute(&storelocation), ::core::mem::transmute(&storename), ::core::mem::transmute(&findyype), ::core::mem::transmute(&findvalue)).into() @@ -42,7 +38,7 @@ impl IChannelCredentials_Vtbl { let this = (*this).get_impl(); this.SetClientCertificateFromFile(::core::mem::transmute(&filename), ::core::mem::transmute(&password), ::core::mem::transmute(&keystorageflags)).into() } - unsafe extern "system" fn SetDefaultServiceCertificateFromStore, Impl: IChannelCredentials_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDefaultServiceCertificateFromStore, Impl: IChannelCredentials_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDefaultServiceCertificateFromStore(::core::mem::transmute(&storelocation), ::core::mem::transmute(&storename), ::core::mem::transmute(&findtype), ::core::mem::transmute(&findvalue)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/mod.rs index 36d26ae57a..ba101f52e2 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/ChannelCredentials/mod.rs @@ -17,15 +17,14 @@ impl IChannelCredentials { { (::windows_core::Interface::vtable(self).SetUserNameCredential)(::windows_core::Interface::as_raw(self), username.into_param().abi(), password.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetClientCertificateFromStore(&self, storelocation: P0, storename: P1, findyype: P2, findvalue: super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetClientCertificateFromStore(&self, storelocation: P0, storename: P1, findyype: P2, findvalue: P3) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetClientCertificateFromStore)(::windows_core::Interface::as_raw(self), storelocation.into_param().abi(), storename.into_param().abi(), findyype.into_param().abi(), ::core::mem::transmute(findvalue)).ok() + (::windows_core::Interface::vtable(self).SetClientCertificateFromStore)(::windows_core::Interface::as_raw(self), storelocation.into_param().abi(), storename.into_param().abi(), findyype.into_param().abi(), findvalue.into_param().abi()).ok() } pub unsafe fn SetClientCertificateFromStoreByName(&self, subjectname: P0, storelocation: P1, storename: P2) -> ::windows_core::Result<()> where @@ -43,15 +42,14 @@ impl IChannelCredentials { { (::windows_core::Interface::vtable(self).SetClientCertificateFromFile)(::windows_core::Interface::as_raw(self), filename.into_param().abi(), password.into_param().abi(), keystorageflags.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDefaultServiceCertificateFromStore(&self, storelocation: P0, storename: P1, findtype: P2, findvalue: super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetDefaultServiceCertificateFromStore(&self, storelocation: P0, storename: P1, findtype: P2, findvalue: P3) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetDefaultServiceCertificateFromStore)(::windows_core::Interface::as_raw(self), storelocation.into_param().abi(), storename.into_param().abi(), findtype.into_param().abi(), ::core::mem::transmute(findvalue)).ok() + (::windows_core::Interface::vtable(self).SetDefaultServiceCertificateFromStore)(::windows_core::Interface::as_raw(self), storelocation.into_param().abi(), storename.into_param().abi(), findtype.into_param().abi(), findvalue.into_param().abi()).ok() } pub unsafe fn SetDefaultServiceCertificateFromStoreByName(&self, subjectname: P0, storelocation: P1, storename: P2) -> ::windows_core::Result<()> where @@ -92,16 +90,10 @@ pub struct IChannelCredentials_Vtbl { pub base__: super::IDispatch_Vtbl, pub SetWindowsCredential: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, domain: ::std::mem::MaybeUninit<::windows_core::BSTR>, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>, impersonationlevel: i32, allowntlm: super::super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetUserNameCredential: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetClientCertificateFromStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findyype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetClientCertificateFromStore: usize, + pub SetClientCertificateFromStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findyype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetClientCertificateFromStoreByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, subjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetClientCertificateFromFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>, keystorageflags: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDefaultServiceCertificateFromStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDefaultServiceCertificateFromStore: usize, + pub SetDefaultServiceCertificateFromStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>, findtype: ::std::mem::MaybeUninit<::windows_core::BSTR>, findvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetDefaultServiceCertificateFromStoreByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, subjectname: ::std::mem::MaybeUninit<::windows_core::BSTR>, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, storename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDefaultServiceCertificateFromFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filename: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>, keystorageflags: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetServiceCertificateAuthentication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, storelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, revocationmode: ::std::mem::MaybeUninit<::windows_core::BSTR>, certificatevalidationmode: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/Events/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Com/Events/impl.rs index c333ab118d..b70754390d 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/Events/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/Events/impl.rs @@ -55,8 +55,6 @@ impl IEnumEventObject_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventClass_Impl: Sized + super::IDispatch_Impl { fn EventClassID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetEventClassID(&self, bstreventclassid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -73,9 +71,7 @@ pub trait IEventClass_Impl: Sized + super::IDispatch_Impl { fn TypeLib(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTypeLib(&self, bstrtypelib: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventClass {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventClass_Vtbl { pub const fn new, Impl: IEventClass_Impl, const OFFSET: isize>() -> IEventClass_Vtbl { unsafe extern "system" fn EventClassID, Impl: IEventClass_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstreventclassid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -212,8 +208,6 @@ impl IEventClass_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventClass2_Impl: Sized + IEventClass_Impl { fn PublisherID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPublisherID(&self, bstrpublisherid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -224,9 +218,7 @@ pub trait IEventClass2_Impl: Sized + IEventClass_Impl { fn FireInParallel(&self) -> ::windows_core::Result; fn SetFireInParallel(&self, ffireinparallel: super::super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventClass2 {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventClass2_Vtbl { pub const fn new, Impl: IEventClass2_Impl, const OFFSET: isize>() -> IEventClass2_Vtbl { unsafe extern "system" fn PublisherID, Impl: IEventClass2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrpublisherid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -309,8 +301,6 @@ impl IEventClass2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventControl_Impl: Sized + super::IDispatch_Impl { fn SetPublisherFilter(&self, methodname: &::windows_core::BSTR, ppublisherfilter: ::core::option::Option<&IPublisherFilter>) -> ::windows_core::Result<()>; fn AllowInprocActivation(&self) -> ::windows_core::Result; @@ -318,9 +308,7 @@ pub trait IEventControl_Impl: Sized + super::IDispatch_Impl { fn GetSubscriptions(&self, methodname: &::windows_core::BSTR, optionalcriteria: &::windows_core::BSTR, optionalerrorindex: *const i32) -> ::windows_core::Result; fn SetDefaultQuery(&self, methodname: &::windows_core::BSTR, criteria: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventControl {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventControl_Vtbl { pub const fn new, Impl: IEventControl_Impl, const OFFSET: isize>() -> IEventControl_Vtbl { unsafe extern "system" fn SetPublisherFilter, Impl: IEventControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, methodname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppublisherfilter: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -440,19 +428,15 @@ impl IEventObjectChange2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventObjectCollection_Impl: Sized + super::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, objectid: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_Item(&self, objectid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn NewEnum(&self) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; - fn Add(&self, item: *const super::super::Variant::VARIANT, objectid: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn Add(&self, item: *const ::windows_core::VARIANT, objectid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Remove(&self, objectid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventObjectCollection {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventObjectCollection_Vtbl { pub const fn new, Impl: IEventObjectCollection_Impl, const OFFSET: isize>() -> IEventObjectCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IEventObjectCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunkenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -466,7 +450,7 @@ impl IEventObjectCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IEventObjectCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IEventObjectCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&objectid)) { @@ -499,7 +483,7 @@ impl IEventObjectCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: IEventObjectCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: *const super::super::Variant::VARIANT, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IEventObjectCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&item), ::core::mem::transmute(&objectid)).into() @@ -523,17 +507,13 @@ impl IEventObjectCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventProperty_Impl: Sized + super::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventProperty {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventProperty_Vtbl { pub const fn new, Impl: IEventProperty_Impl, const OFFSET: isize>() -> IEventProperty_Vtbl { unsafe extern "system" fn Name, Impl: IEventProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -552,7 +532,7 @@ impl IEventProperty_Vtbl { let this = (*this).get_impl(); this.SetName(::core::mem::transmute(&propertyname)).into() } - unsafe extern "system" fn Value, Impl: IEventProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IEventProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -563,7 +543,7 @@ impl IEventProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IEventProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IEventProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&propertyvalue)).into() @@ -580,8 +560,6 @@ impl IEventProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventPublisher_Impl: Sized + super::IDispatch_Impl { fn PublisherID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPublisherID(&self, bstrpublisherid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -593,14 +571,12 @@ pub trait IEventPublisher_Impl: Sized + super::IDispatch_Impl { fn SetOwnerSID(&self, bstrownersid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetDefaultProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; - fn PutDefaultProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetDefaultProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutDefaultProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RemoveDefaultProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetDefaultPropertyCollection(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventPublisher {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventPublisher_Vtbl { pub const fn new, Impl: IEventPublisher_Impl, const OFFSET: isize>() -> IEventPublisher_Vtbl { unsafe extern "system" fn PublisherID, Impl: IEventPublisher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrpublisherid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -683,7 +659,7 @@ impl IEventPublisher_Vtbl { let this = (*this).get_impl(); this.SetDescription(::core::mem::transmute(&bstrdescription)).into() } - unsafe extern "system" fn GetDefaultProperty, Impl: IEventPublisher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDefaultProperty, Impl: IEventPublisher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDefaultProperty(::core::mem::transmute(&bstrpropertyname)) { @@ -694,7 +670,7 @@ impl IEventPublisher_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutDefaultProperty, Impl: IEventPublisher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutDefaultProperty, Impl: IEventPublisher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutDefaultProperty(::core::mem::transmute(&bstrpropertyname), ::core::mem::transmute_copy(&propertyvalue)).into() @@ -737,8 +713,6 @@ impl IEventPublisher_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventSubscription_Impl: Sized + super::IDispatch_Impl { fn SubscriptionID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSubscriptionID(&self, bstrsubscriptionid: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -764,20 +738,18 @@ pub trait IEventSubscription_Impl: Sized + super::IDispatch_Impl { fn SetDescription(&self, bstrdescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn MachineName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMachineName(&self, bstrmachinename: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetPublisherProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; - fn PutPublisherProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetPublisherProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutPublisherProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RemovePublisherProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetPublisherPropertyCollection(&self) -> ::windows_core::Result; - fn GetSubscriberProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; - fn PutSubscriberProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetSubscriberProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutSubscriberProperty(&self, bstrpropertyname: &::windows_core::BSTR, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RemoveSubscriberProperty(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetSubscriberPropertyCollection(&self) -> ::windows_core::Result; fn InterfaceID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetInterfaceID(&self, bstrinterfaceid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventSubscription {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventSubscription_Vtbl { pub const fn new, Impl: IEventSubscription_Impl, const OFFSET: isize>() -> IEventSubscription_Vtbl { unsafe extern "system" fn SubscriptionID, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsubscriptionid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -972,7 +944,7 @@ impl IEventSubscription_Vtbl { let this = (*this).get_impl(); this.SetMachineName(::core::mem::transmute(&bstrmachinename)).into() } - unsafe extern "system" fn GetPublisherProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPublisherProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPublisherProperty(::core::mem::transmute(&bstrpropertyname)) { @@ -983,7 +955,7 @@ impl IEventSubscription_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutPublisherProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutPublisherProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutPublisherProperty(::core::mem::transmute(&bstrpropertyname), ::core::mem::transmute_copy(&propertyvalue)).into() @@ -1004,7 +976,7 @@ impl IEventSubscription_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetSubscriberProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSubscriberProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSubscriberProperty(::core::mem::transmute(&bstrpropertyname)) { @@ -1015,7 +987,7 @@ impl IEventSubscription_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutSubscriberProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutSubscriberProperty, Impl: IEventSubscription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutSubscriberProperty(::core::mem::transmute(&bstrpropertyname), ::core::mem::transmute_copy(&propertyvalue)).into() @@ -1094,8 +1066,6 @@ impl IEventSubscription_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEventSystem_Impl: Sized + super::IDispatch_Impl { fn Query(&self, progid: &::windows_core::BSTR, querycriteria: &::windows_core::BSTR, errorindex: *mut i32, ppinterface: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn Store(&self, progid: &::windows_core::BSTR, pinterface: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; @@ -1104,9 +1074,7 @@ pub trait IEventSystem_Impl: Sized + super::IDispatch_Impl { fn QueryS(&self, progid: &::windows_core::BSTR, querycriteria: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; fn RemoveS(&self, progid: &::windows_core::BSTR, querycriteria: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEventSystem {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEventSystem_Vtbl { pub const fn new, Impl: IEventSystem_Impl, const OFFSET: isize>() -> IEventSystem_Vtbl { unsafe extern "system" fn Query, Impl: IEventSystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, progid: ::std::mem::MaybeUninit<::windows_core::BSTR>, querycriteria: ::std::mem::MaybeUninit<::windows_core::BSTR>, errorindex: *mut i32, ppinterface: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1171,14 +1139,10 @@ impl IEventSystem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IFiringControl_Impl: Sized + super::IDispatch_Impl { fn FireSubscription(&self, subscription: ::core::option::Option<&IEventSubscription>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IFiringControl {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IFiringControl_Vtbl { pub const fn new, Impl: IFiringControl_Impl, const OFFSET: isize>() -> IFiringControl_Vtbl { unsafe extern "system" fn FireSubscription, Impl: IFiringControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, subscription: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/Events/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Com/Events/mod.rs index 4553a2ecf1..bafca014e7 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/Events/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/Events/mod.rs @@ -353,9 +353,7 @@ impl IEventObjectCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, objectid: P0) -> ::windows_core::Result + pub unsafe fn get_Item(&self, objectid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -370,13 +368,11 @@ impl IEventObjectCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, item: *const super::super::Variant::VARIANT, objectid: P0) -> ::windows_core::Result<()> + pub unsafe fn Add(&self, item: *const ::windows_core::VARIANT, objectid: P0) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), item, objectid.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(item), objectid.into_param().abi()).ok() } pub unsafe fn Remove(&self, objectid: P0) -> ::windows_core::Result<()> where @@ -390,16 +386,10 @@ impl IEventObjectCollection { pub struct IEventObjectCollection_Vtbl { pub base__: super::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunkenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: *const super::super::Variant::VARIANT, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IEventProperty, IEventProperty_Vtbl, 0xda538ee2_f4de_11d1_b6bb_00805fc79216); @@ -415,16 +405,12 @@ impl IEventProperty { { (::windows_core::Interface::vtable(self).SetName)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), propertyvalue).ok() + pub unsafe fn SetValue(&self, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propertyvalue)).ok() } } #[repr(C)] @@ -433,14 +419,8 @@ pub struct IEventProperty_Vtbl { pub base__: super::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IEventPublisher, IEventPublisher_Vtbl, 0xe341516b_2e32_11d1_9964_00c04fbbb345); ::windows_core::imp::interface_hierarchy!(IEventPublisher, ::windows_core::IUnknown, super::IDispatch); @@ -495,22 +475,18 @@ impl IEventPublisher { { (::windows_core::Interface::vtable(self).SetDescription)(::windows_core::Interface::as_raw(self), bstrdescription.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDefaultProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn GetDefaultProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDefaultProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutDefaultProperty(&self, bstrpropertyname: P0, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutDefaultProperty(&self, bstrpropertyname: P0, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).PutDefaultProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), propertyvalue).ok() + (::windows_core::Interface::vtable(self).PutDefaultProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(propertyvalue)).ok() } pub unsafe fn RemoveDefaultProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<()> where @@ -537,14 +513,8 @@ pub struct IEventPublisher_Vtbl { pub SetOwnerSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrownersid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDefaultProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDefaultProperty: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutDefaultProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutDefaultProperty: usize, + pub GetDefaultProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutDefaultProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RemoveDefaultProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetDefaultPropertyCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -671,22 +641,18 @@ impl IEventSubscription { { (::windows_core::Interface::vtable(self).SetMachineName)(::windows_core::Interface::as_raw(self), bstrmachinename.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPublisherProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn GetPublisherProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPublisherProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutPublisherProperty(&self, bstrpropertyname: P0, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutPublisherProperty(&self, bstrpropertyname: P0, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).PutPublisherProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), propertyvalue).ok() + (::windows_core::Interface::vtable(self).PutPublisherProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(propertyvalue)).ok() } pub unsafe fn RemovePublisherProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<()> where @@ -698,22 +664,18 @@ impl IEventSubscription { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPublisherPropertyCollection)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSubscriberProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn GetSubscriberProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetSubscriberProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutSubscriberProperty(&self, bstrpropertyname: P0, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutSubscriberProperty(&self, bstrpropertyname: P0, propertyvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).PutSubscriberProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), propertyvalue).ok() + (::windows_core::Interface::vtable(self).PutSubscriberProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(propertyvalue)).ok() } pub unsafe fn RemoveSubscriberProperty(&self, bstrpropertyname: P0) -> ::windows_core::Result<()> where @@ -764,24 +726,12 @@ pub struct IEventSubscription_Vtbl { pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub MachineName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrmachinename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetMachineName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmachinename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPublisherProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPublisherProperty: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutPublisherProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutPublisherProperty: usize, + pub GetPublisherProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutPublisherProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RemovePublisherProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetPublisherPropertyCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSubscriberProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSubscriberProperty: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutSubscriberProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutSubscriberProperty: usize, + pub GetSubscriberProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutSubscriberProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RemoveSubscriberProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetSubscriberPropertyCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub InterfaceID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrinterfaceid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/impl.rs index 6d8cc4a828..da20caaeb6 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/impl.rs @@ -395,23 +395,19 @@ impl IPersistStorage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IPropertyBag_Impl: Sized { - fn Read(&self, pszpropname: &::windows_core::PCWSTR, pvar: *mut super::super::Variant::VARIANT, perrorlog: ::core::option::Option<&super::IErrorLog>) -> ::windows_core::Result<()>; - fn Write(&self, pszpropname: &::windows_core::PCWSTR, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Read(&self, pszpropname: &::windows_core::PCWSTR, pvar: *mut ::windows_core::VARIANT, perrorlog: ::core::option::Option<&super::IErrorLog>) -> ::windows_core::Result<()>; + fn Write(&self, pszpropname: &::windows_core::PCWSTR, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyBag {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IPropertyBag_Vtbl { pub const fn new, Impl: IPropertyBag_Impl, const OFFSET: isize>() -> IPropertyBag_Vtbl { - unsafe extern "system" fn Read, Impl: IPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *mut super::super::Variant::VARIANT, perrorlog: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Read, Impl: IPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, perrorlog: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Read(::core::mem::transmute(&pszpropname), ::core::mem::transmute_copy(&pvar), ::windows_core::from_raw_borrowed(&perrorlog)).into() } - unsafe extern "system" fn Write, Impl: IPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Write, Impl: IPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Write(::core::mem::transmute(&pszpropname), ::core::mem::transmute_copy(&pvar)).into() @@ -422,26 +418,26 @@ impl IPropertyBag_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Variant\"`"] +#[cfg(feature = "Win32_System_Variant")] pub trait IPropertyBag2_Impl: Sized { - fn Read(&self, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: ::core::option::Option<&super::IErrorLog>, pvarvalue: *mut super::super::Variant::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::Result<()>; - fn Write(&self, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Read(&self, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: ::core::option::Option<&super::IErrorLog>, pvarvalue: *mut ::windows_core::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::Result<()>; + fn Write(&self, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn CountProperties(&self) -> ::windows_core::Result; fn GetPropertyInfo(&self, iproperty: u32, cproperties: u32, ppropbag: *mut PROPBAG2, pcproperties: *mut u32) -> ::windows_core::Result<()>; fn LoadObject(&self, pstrname: &::windows_core::PCWSTR, dwhint: u32, punkobject: ::core::option::Option<&::windows_core::IUnknown>, perrlog: ::core::option::Option<&super::IErrorLog>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::RuntimeName for IPropertyBag2 {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl IPropertyBag2_Vtbl { pub const fn new, Impl: IPropertyBag2_Impl, const OFFSET: isize>() -> IPropertyBag2_Vtbl { - unsafe extern "system" fn Read, Impl: IPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::Variant::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Read, Impl: IPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Read(::core::mem::transmute_copy(&cproperties), ::core::mem::transmute_copy(&ppropbag), ::windows_core::from_raw_borrowed(&perrlog), ::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&phrerror)).into() } - unsafe extern "system" fn Write, Impl: IPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Write, Impl: IPropertyBag2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Write(::core::mem::transmute_copy(&cproperties), ::core::mem::transmute_copy(&ppropbag), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -539,11 +535,9 @@ impl IPropertySetStorage_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] pub trait IPropertyStorage_Impl: Sized { - fn ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows_core::Result<()>; - fn WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()>; + fn ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const ::windows_core::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()>; fn DeleteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC) -> ::windows_core::Result<()>; fn ReadPropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn WritePropertyNames(&self, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const ::windows_core::PCWSTR) -> ::windows_core::Result<()>; @@ -555,17 +549,15 @@ pub trait IPropertyStorage_Impl: Sized { fn SetClass(&self, clsid: *const ::windows_core::GUID) -> ::windows_core::Result<()>; fn Stat(&self, pstatpsstg: *mut STATPROPSETSTG) -> ::windows_core::Result<()>; } -#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::RuntimeName for IPropertyStorage {} -#[cfg(feature = "Win32_System_Variant")] impl IPropertyStorage_Vtbl { pub const fn new, Impl: IPropertyStorage_Impl, const OFFSET: isize>() -> IPropertyStorage_Vtbl { - unsafe extern "system" fn ReadMultiple, Impl: IPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadMultiple, Impl: IPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ReadMultiple(::core::mem::transmute_copy(&cpspec), ::core::mem::transmute_copy(&rgpspec), ::core::mem::transmute_copy(&rgpropvar)).into() } - unsafe extern "system" fn WriteMultiple, Impl: IPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn WriteMultiple, Impl: IPropertyStorage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propidnamefirst: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WriteMultiple(::core::mem::transmute_copy(&cpspec), ::core::mem::transmute_copy(&rgpspec), ::core::mem::transmute_copy(&rgpropvar), ::core::mem::transmute_copy(&propidnamefirst)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/mod.rs index 58a93db86d..afe50888f9 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/StructuredStorage/mod.rs @@ -1,8 +1,6 @@ -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn ClearPropVariantArray(rgpropvar: &mut [PROPVARIANT]) { - ::windows_targets::link!("propsys.dll" "system" fn ClearPropVariantArray(rgpropvar : *mut PROPVARIANT, cvars : u32)); +pub unsafe fn ClearPropVariantArray(rgpropvar: &mut [::windows_core::PROPVARIANT]) { + ::windows_targets::link!("propsys.dll" "system" fn ClearPropVariantArray(rgpropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, cvars : u32)); ClearPropVariantArray(::core::mem::transmute(rgpropvar.as_ptr()), rgpropvar.len().try_into().unwrap()) } #[inline] @@ -58,11 +56,9 @@ pub unsafe fn FmtIdToPropStgName(pfmtid: *const ::windows_core::GUID, oszname: : ::windows_targets::link!("ole32.dll" "system" fn FmtIdToPropStgName(pfmtid : *const ::windows_core::GUID, oszname : ::windows_core::PWSTR) -> ::windows_core::HRESULT); FmtIdToPropStgName(pfmtid, ::core::mem::transmute(oszname)).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn FreePropVariantArray(rgvars: &mut [PROPVARIANT]) -> ::windows_core::Result<()> { - ::windows_targets::link!("ole32.dll" "system" fn FreePropVariantArray(cvariants : u32, rgvars : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn FreePropVariantArray(rgvars: &mut [::windows_core::PROPVARIANT]) -> ::windows_core::Result<()> { + ::windows_targets::link!("ole32.dll" "system" fn FreePropVariantArray(cvariants : u32, rgvars : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); FreePropVariantArray(rgvars.len().try_into().unwrap(), ::core::mem::transmute(rgvars.as_ptr())).ok() } #[inline] @@ -91,155 +87,119 @@ where let mut result__ = ::std::mem::zeroed(); GetHGlobalFromStream(pstm.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromBooleanVector(prgf: ::core::option::Option<&[super::super::super::Foundation::BOOL]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromBooleanVector(prgf : *const super::super::super::Foundation:: BOOL, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromBooleanVector(prgf: ::core::option::Option<&[super::super::super::Foundation::BOOL]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromBooleanVector(prgf : *const super::super::super::Foundation:: BOOL, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromBooleanVector(::core::mem::transmute(prgf.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgf.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromBuffer(pv: *const ::core::ffi::c_void, cb: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromBuffer(pv : *const ::core::ffi::c_void, cb : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromBuffer(pv: *const ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromBuffer(pv : *const ::core::ffi::c_void, cb : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromBuffer(pv, cb, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromCLSID(clsid: *const ::windows_core::GUID) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromCLSID(clsid : *const ::windows_core::GUID, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromCLSID(clsid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromCLSID(clsid : *const ::windows_core::GUID, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromCLSID(clsid, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromDoubleVector(prgn: ::core::option::Option<&[f64]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromDoubleVector(prgn : *const f64, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromDoubleVector(prgn: ::core::option::Option<&[f64]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromDoubleVector(prgn : *const f64, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromDoubleVector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromFileTime(pftin: *const super::super::super::Foundation::FILETIME) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromFileTime(pftin : *const super::super::super::Foundation:: FILETIME, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromFileTime(pftin: *const super::super::super::Foundation::FILETIME) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromFileTime(pftin : *const super::super::super::Foundation:: FILETIME, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromFileTime(pftin, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromFileTimeVector(prgft: ::core::option::Option<&[super::super::super::Foundation::FILETIME]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromFileTimeVector(prgft : *const super::super::super::Foundation:: FILETIME, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromFileTimeVector(prgft: ::core::option::Option<&[super::super::super::Foundation::FILETIME]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromFileTimeVector(prgft : *const super::super::super::Foundation:: FILETIME, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromFileTimeVector(::core::mem::transmute(prgft.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgft.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromGUIDAsString(guid: *const ::windows_core::GUID) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromGUIDAsString(guid : *const ::windows_core::GUID, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromGUIDAsString(guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromGUIDAsString(guid : *const ::windows_core::GUID, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromGUIDAsString(guid, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromInt16Vector(prgn: ::core::option::Option<&[i16]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt16Vector(prgn : *const i16, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromInt16Vector(prgn: ::core::option::Option<&[i16]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt16Vector(prgn : *const i16, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromInt16Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromInt32Vector(prgn: ::core::option::Option<&[i32]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt32Vector(prgn : *const i32, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromInt32Vector(prgn: ::core::option::Option<&[i32]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt32Vector(prgn : *const i32, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromInt32Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromInt64Vector(prgn: ::core::option::Option<&[i64]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt64Vector(prgn : *const i64, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromInt64Vector(prgn: ::core::option::Option<&[i64]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromInt64Vector(prgn : *const i64, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromInt64Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromPropVariantVectorElem(propvarin: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromPropVariantVectorElem(propvarin : *const PROPVARIANT, ielem : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromPropVariantVectorElem(propvarin: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromPropVariantVectorElem(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - InitPropVariantFromPropVariantVectorElem(propvarin, ielem, &mut result__).from_abi(result__) + InitPropVariantFromPropVariantVectorElem(::core::mem::transmute(propvarin), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromResource(hinst: P0, id: u32) -> ::windows_core::Result +pub unsafe fn InitPropVariantFromResource(hinst: P0, id: u32) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromResource(hinst : super::super::super::Foundation:: HINSTANCE, id : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromResource(hinst : super::super::super::Foundation:: HINSTANCE, id : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromResource(hinst.into_param().abi(), id, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromStringAsVector(psz: P0) -> ::windows_core::Result +pub unsafe fn InitPropVariantFromStringAsVector(psz: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStringAsVector(psz : ::windows_core::PCWSTR, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStringAsVector(psz : ::windows_core::PCWSTR, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromStringAsVector(psz.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromStringVector(prgsz: ::core::option::Option<&[::windows_core::PCWSTR]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStringVector(prgsz : *const ::windows_core::PCWSTR, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromStringVector(prgsz: ::core::option::Option<&[::windows_core::PCWSTR]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStringVector(prgsz : *const ::windows_core::PCWSTR, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromStringVector(::core::mem::transmute(prgsz.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgsz.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromUInt16Vector(prgn: ::core::option::Option<&[u16]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt16Vector(prgn : *const u16, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromUInt16Vector(prgn: ::core::option::Option<&[u16]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt16Vector(prgn : *const u16, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromUInt16Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromUInt32Vector(prgn: ::core::option::Option<&[u32]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt32Vector(prgn : *const u32, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromUInt32Vector(prgn: ::core::option::Option<&[u32]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt32Vector(prgn : *const u32, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromUInt32Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantFromUInt64Vector(prgn: ::core::option::Option<&[u64]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt64Vector(prgn : *const u64, celems : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantFromUInt64Vector(prgn: ::core::option::Option<&[u64]>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromUInt64Vector(prgn : *const u64, celems : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitPropVariantFromUInt64Vector(::core::mem::transmute(prgn.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgn.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn InitPropVariantVectorFromPropVariant(propvarsingle: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantVectorFromPropVariant(propvarsingle : *const PROPVARIANT, ppropvarvector : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitPropVariantVectorFromPropVariant(propvarsingle: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantVectorFromPropVariant(propvarsingle : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ppropvarvector : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - InitPropVariantVectorFromPropVariant(propvarsingle, &mut result__).from_abi(result__) + InitPropVariantVectorFromPropVariant(::core::mem::transmute(propvarsingle), &mut result__).from_abi(result__) } #[inline] pub unsafe fn OleConvertIStorageToOLESTREAM(pstg: P0) -> ::windows_core::Result @@ -291,455 +251,339 @@ where #[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantChangeType(ppropvardest: *mut PROPVARIANT, propvarsrc: *const PROPVARIANT, flags: PROPVAR_CHANGE_FLAGS, vt: super::super::Variant::VARENUM) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantChangeType(ppropvardest : *mut PROPVARIANT, propvarsrc : *const PROPVARIANT, flags : PROPVAR_CHANGE_FLAGS, vt : super::super::Variant:: VARENUM) -> ::windows_core::HRESULT); - PropVariantChangeType(ppropvardest, propvarsrc, flags, vt).ok() +pub unsafe fn PropVariantChangeType(ppropvardest: *mut ::windows_core::PROPVARIANT, propvarsrc: *const ::windows_core::PROPVARIANT, flags: PROPVAR_CHANGE_FLAGS, vt: super::super::Variant::VARENUM) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantChangeType(ppropvardest : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, propvarsrc : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, flags : PROPVAR_CHANGE_FLAGS, vt : super::super::Variant:: VARENUM) -> ::windows_core::HRESULT); + PropVariantChangeType(::core::mem::transmute(ppropvardest), ::core::mem::transmute(propvarsrc), flags, vt).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantClear(pvar: *mut PROPVARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("ole32.dll" "system" fn PropVariantClear(pvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); - PropVariantClear(pvar).ok() +pub unsafe fn PropVariantClear(pvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("ole32.dll" "system" fn PropVariantClear(pvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + PropVariantClear(::core::mem::transmute(pvar)).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantCompareEx(propvar1: *const PROPVARIANT, propvar2: *const PROPVARIANT, unit: PROPVAR_COMPARE_UNIT, flags: PROPVAR_COMPARE_FLAGS) -> i32 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantCompareEx(propvar1 : *const PROPVARIANT, propvar2 : *const PROPVARIANT, unit : PROPVAR_COMPARE_UNIT, flags : PROPVAR_COMPARE_FLAGS) -> i32); - PropVariantCompareEx(propvar1, propvar2, unit, flags) +pub unsafe fn PropVariantCompareEx(propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, unit: PROPVAR_COMPARE_UNIT, flags: PROPVAR_COMPARE_FLAGS) -> i32 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantCompareEx(propvar1 : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, propvar2 : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, unit : PROPVAR_COMPARE_UNIT, flags : PROPVAR_COMPARE_FLAGS) -> i32); + PropVariantCompareEx(::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), unit, flags) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantCopy(pvardest: *mut PROPVARIANT, pvarsrc: *const PROPVARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("ole32.dll" "system" fn PropVariantCopy(pvardest : *mut PROPVARIANT, pvarsrc : *const PROPVARIANT) -> ::windows_core::HRESULT); - PropVariantCopy(pvardest, pvarsrc).ok() +pub unsafe fn PropVariantCopy(pvardest: *mut ::windows_core::PROPVARIANT, pvarsrc: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("ole32.dll" "system" fn PropVariantCopy(pvardest : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pvarsrc : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + PropVariantCopy(::core::mem::transmute(pvardest), ::core::mem::transmute(pvarsrc)).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetBooleanElem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetBooleanElem(propvar : *const PROPVARIANT, ielem : u32, pfval : *mut super::super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetBooleanElem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetBooleanElem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pfval : *mut super::super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetBooleanElem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetBooleanElem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetDoubleElem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetDoubleElem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut f64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetDoubleElem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetDoubleElem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut f64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetDoubleElem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetDoubleElem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetElementCount(propvar: *const PROPVARIANT) -> u32 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetElementCount(propvar : *const PROPVARIANT) -> u32); - PropVariantGetElementCount(propvar) +pub unsafe fn PropVariantGetElementCount(propvar: *const ::windows_core::PROPVARIANT) -> u32 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetElementCount(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> u32); + PropVariantGetElementCount(::core::mem::transmute(propvar)) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetFileTimeElem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetFileTimeElem(propvar : *const PROPVARIANT, ielem : u32, pftval : *mut super::super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetFileTimeElem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetFileTimeElem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pftval : *mut super::super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetFileTimeElem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetFileTimeElem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetInt16Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt16Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut i16) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetInt16Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt16Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut i16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetInt16Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetInt16Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetInt32Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt32Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut i32) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetInt32Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt32Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut i32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetInt32Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetInt32Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetInt64Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt64Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut i64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetInt64Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetInt64Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut i64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetInt64Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetInt64Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetStringElem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetStringElem(propvar : *const PROPVARIANT, ielem : u32, ppszval : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetStringElem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetStringElem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, ppszval : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetStringElem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetStringElem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetUInt16Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt16Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut u16) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetUInt16Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt16Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut u16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetUInt16Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetUInt16Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetUInt32Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt32Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut u32) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetUInt32Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt32Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut u32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetUInt32Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetUInt32Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantGetUInt64Elem(propvar: *const PROPVARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt64Elem(propvar : *const PROPVARIANT, ielem : u32, pnval : *mut u64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantGetUInt64Elem(propvar: *const ::windows_core::PROPVARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantGetUInt64Elem(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ielem : u32, pnval : *mut u64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantGetUInt64Elem(propvar, ielem, &mut result__).from_abi(result__) + PropVariantGetUInt64Elem(::core::mem::transmute(propvar), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBSTR(propvar: *const PROPVARIANT) -> ::windows_core::Result<::windows_core::BSTR> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBSTR(propvar : *const PROPVARIANT, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToBSTR(propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBSTR(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToBSTR(propvar, &mut result__).from_abi(result__) + PropVariantToBSTR(::core::mem::transmute(propvar), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBoolean(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBoolean(propvarin : *const PROPVARIANT, pfret : *mut super::super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToBoolean(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBoolean(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pfret : *mut super::super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToBoolean(propvarin, &mut result__).from_abi(result__) + PropVariantToBoolean(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBooleanVector(propvar: *const PROPVARIANT, prgf: &mut [super::super::super::Foundation::BOOL], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanVector(propvar : *const PROPVARIANT, prgf : *mut super::super::super::Foundation:: BOOL, crgf : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToBooleanVector(propvar, ::core::mem::transmute(prgf.as_ptr()), prgf.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToBooleanVector(propvar: *const ::windows_core::PROPVARIANT, prgf: &mut [super::super::super::Foundation::BOOL], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanVector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgf : *mut super::super::super::Foundation:: BOOL, crgf : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToBooleanVector(::core::mem::transmute(propvar), ::core::mem::transmute(prgf.as_ptr()), prgf.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBooleanVectorAlloc(propvar: *const PROPVARIANT, pprgf: *mut *mut super::super::super::Foundation::BOOL, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanVectorAlloc(propvar : *const PROPVARIANT, pprgf : *mut *mut super::super::super::Foundation:: BOOL, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToBooleanVectorAlloc(propvar, pprgf, pcelem).ok() +pub unsafe fn PropVariantToBooleanVectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgf: *mut *mut super::super::super::Foundation::BOOL, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanVectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgf : *mut *mut super::super::super::Foundation:: BOOL, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToBooleanVectorAlloc(::core::mem::transmute(propvar), pprgf, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBooleanWithDefault(propvarin: *const PROPVARIANT, fdefault: P0) -> super::super::super::Foundation::BOOL +pub unsafe fn PropVariantToBooleanWithDefault(propvarin: *const ::windows_core::PROPVARIANT, fdefault: P0) -> super::super::super::Foundation::BOOL where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanWithDefault(propvarin : *const PROPVARIANT, fdefault : super::super::super::Foundation:: BOOL) -> super::super::super::Foundation:: BOOL); - PropVariantToBooleanWithDefault(propvarin, fdefault.into_param().abi()) + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBooleanWithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, fdefault : super::super::super::Foundation:: BOOL) -> super::super::super::Foundation:: BOOL); + PropVariantToBooleanWithDefault(::core::mem::transmute(propvarin), fdefault.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToBuffer(propvar: *const PROPVARIANT, pv: *mut ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBuffer(propvar : *const PROPVARIANT, pv : *mut ::core::ffi::c_void, cb : u32) -> ::windows_core::HRESULT); - PropVariantToBuffer(propvar, pv, cb).ok() +pub unsafe fn PropVariantToBuffer(propvar: *const ::windows_core::PROPVARIANT, pv: *mut ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToBuffer(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pv : *mut ::core::ffi::c_void, cb : u32) -> ::windows_core::HRESULT); + PropVariantToBuffer(::core::mem::transmute(propvar), pv, cb).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToDouble(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDouble(propvarin : *const PROPVARIANT, pdblret : *mut f64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToDouble(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDouble(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pdblret : *mut f64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToDouble(propvarin, &mut result__).from_abi(result__) + PropVariantToDouble(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToDoubleVector(propvar: *const PROPVARIANT, prgn: &mut [f64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleVector(propvar : *const PROPVARIANT, prgn : *mut f64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToDoubleVector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToDoubleVector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [f64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleVector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut f64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToDoubleVector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToDoubleVectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut f64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleVectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut f64, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToDoubleVectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToDoubleVectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut f64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleVectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut f64, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToDoubleVectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToDoubleWithDefault(propvarin: *const PROPVARIANT, dbldefault: f64) -> f64 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleWithDefault(propvarin : *const PROPVARIANT, dbldefault : f64) -> f64); - PropVariantToDoubleWithDefault(propvarin, dbldefault) +pub unsafe fn PropVariantToDoubleWithDefault(propvarin: *const ::windows_core::PROPVARIANT, dbldefault: f64) -> f64 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToDoubleWithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, dbldefault : f64) -> f64); + PropVariantToDoubleWithDefault(::core::mem::transmute(propvarin), dbldefault) } #[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToFileTime(propvar: *const PROPVARIANT, pstfout: super::super::Variant::PSTIME_FLAGS) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTime(propvar : *const PROPVARIANT, pstfout : super::super::Variant:: PSTIME_FLAGS, pftout : *mut super::super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToFileTime(propvar: *const ::windows_core::PROPVARIANT, pstfout: super::super::Variant::PSTIME_FLAGS) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTime(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pstfout : super::super::Variant:: PSTIME_FLAGS, pftout : *mut super::super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToFileTime(propvar, pstfout, &mut result__).from_abi(result__) + PropVariantToFileTime(::core::mem::transmute(propvar), pstfout, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToFileTimeVector(propvar: *const PROPVARIANT, prgft: &mut [super::super::super::Foundation::FILETIME], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTimeVector(propvar : *const PROPVARIANT, prgft : *mut super::super::super::Foundation:: FILETIME, crgft : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToFileTimeVector(propvar, ::core::mem::transmute(prgft.as_ptr()), prgft.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToFileTimeVector(propvar: *const ::windows_core::PROPVARIANT, prgft: &mut [super::super::super::Foundation::FILETIME], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTimeVector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgft : *mut super::super::super::Foundation:: FILETIME, crgft : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToFileTimeVector(::core::mem::transmute(propvar), ::core::mem::transmute(prgft.as_ptr()), prgft.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToFileTimeVectorAlloc(propvar: *const PROPVARIANT, pprgft: *mut *mut super::super::super::Foundation::FILETIME, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTimeVectorAlloc(propvar : *const PROPVARIANT, pprgft : *mut *mut super::super::super::Foundation:: FILETIME, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToFileTimeVectorAlloc(propvar, pprgft, pcelem).ok() +pub unsafe fn PropVariantToFileTimeVectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgft: *mut *mut super::super::super::Foundation::FILETIME, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToFileTimeVectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgft : *mut *mut super::super::super::Foundation:: FILETIME, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToFileTimeVectorAlloc(::core::mem::transmute(propvar), pprgft, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToGUID(propvar: *const PROPVARIANT) -> ::windows_core::Result<::windows_core::GUID> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToGUID(propvar : *const PROPVARIANT, pguid : *mut ::windows_core::GUID) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToGUID(propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::GUID> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToGUID(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pguid : *mut ::windows_core::GUID) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToGUID(propvar, &mut result__).from_abi(result__) + PropVariantToGUID(::core::mem::transmute(propvar), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt16(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16(propvarin : *const PROPVARIANT, piret : *mut i16) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToInt16(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, piret : *mut i16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToInt16(propvarin, &mut result__).from_abi(result__) + PropVariantToInt16(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt16Vector(propvar: *const PROPVARIANT, prgn: &mut [i16], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16Vector(propvar : *const PROPVARIANT, prgn : *mut i16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt16Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToInt16Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [i16], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut i16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt16Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt16VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut i16, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut i16, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt16VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToInt16VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut i16, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut i16, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt16VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt16WithDefault(propvarin: *const PROPVARIANT, idefault: i16) -> i16 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16WithDefault(propvarin : *const PROPVARIANT, idefault : i16) -> i16); - PropVariantToInt16WithDefault(propvarin, idefault) +pub unsafe fn PropVariantToInt16WithDefault(propvarin: *const ::windows_core::PROPVARIANT, idefault: i16) -> i16 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, idefault : i16) -> i16); + PropVariantToInt16WithDefault(::core::mem::transmute(propvarin), idefault) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt32(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32(propvarin : *const PROPVARIANT, plret : *mut i32) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToInt32(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, plret : *mut i32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToInt32(propvarin, &mut result__).from_abi(result__) + PropVariantToInt32(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt32Vector(propvar: *const PROPVARIANT, prgn: &mut [i32], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32Vector(propvar : *const PROPVARIANT, prgn : *mut i32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt32Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToInt32Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [i32], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut i32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt32Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt32VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut i32, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut i32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt32VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToInt32VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut i32, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut i32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt32VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt32WithDefault(propvarin: *const PROPVARIANT, ldefault: i32) -> i32 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32WithDefault(propvarin : *const PROPVARIANT, ldefault : i32) -> i32); - PropVariantToInt32WithDefault(propvarin, ldefault) +pub unsafe fn PropVariantToInt32WithDefault(propvarin: *const ::windows_core::PROPVARIANT, ldefault: i32) -> i32 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ldefault : i32) -> i32); + PropVariantToInt32WithDefault(::core::mem::transmute(propvarin), ldefault) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt64(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64(propvarin : *const PROPVARIANT, pllret : *mut i64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToInt64(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pllret : *mut i64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToInt64(propvarin, &mut result__).from_abi(result__) + PropVariantToInt64(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt64Vector(propvar: *const PROPVARIANT, prgn: &mut [i64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64Vector(propvar : *const PROPVARIANT, prgn : *mut i64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt64Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToInt64Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [i64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut i64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt64Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt64VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut i64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut i64, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToInt64VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToInt64VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut i64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut i64, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToInt64VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToInt64WithDefault(propvarin: *const PROPVARIANT, lldefault: i64) -> i64 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64WithDefault(propvarin : *const PROPVARIANT, lldefault : i64) -> i64); - PropVariantToInt64WithDefault(propvarin, lldefault) +pub unsafe fn PropVariantToInt64WithDefault(propvarin: *const ::windows_core::PROPVARIANT, lldefault: i64) -> i64 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, lldefault : i64) -> i64); + PropVariantToInt64WithDefault(::core::mem::transmute(propvarin), lldefault) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToString(propvar: *const PROPVARIANT, psz: &mut [u16]) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToString(propvar : *const PROPVARIANT, psz : ::windows_core::PWSTR, cch : u32) -> ::windows_core::HRESULT); - PropVariantToString(propvar, ::core::mem::transmute(psz.as_ptr()), psz.len().try_into().unwrap()).ok() +pub unsafe fn PropVariantToString(propvar: *const ::windows_core::PROPVARIANT, psz: &mut [u16]) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToString(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, psz : ::windows_core::PWSTR, cch : u32) -> ::windows_core::HRESULT); + PropVariantToString(::core::mem::transmute(propvar), ::core::mem::transmute(psz.as_ptr()), psz.len().try_into().unwrap()).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToStringAlloc(propvar: *const PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringAlloc(propvar : *const PROPVARIANT, ppszout : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToStringAlloc(propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ppszout : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToStringAlloc(propvar, &mut result__).from_abi(result__) + PropVariantToStringAlloc(::core::mem::transmute(propvar), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToStringVector(propvar: *const PROPVARIANT, prgsz: &mut [::windows_core::PWSTR], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringVector(propvar : *const PROPVARIANT, prgsz : *mut ::windows_core::PWSTR, crgsz : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToStringVector(propvar, ::core::mem::transmute(prgsz.as_ptr()), prgsz.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToStringVector(propvar: *const ::windows_core::PROPVARIANT, prgsz: &mut [::windows_core::PWSTR], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringVector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgsz : *mut ::windows_core::PWSTR, crgsz : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToStringVector(::core::mem::transmute(propvar), ::core::mem::transmute(prgsz.as_ptr()), prgsz.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToStringVectorAlloc(propvar: *const PROPVARIANT, pprgsz: *mut *mut ::windows_core::PWSTR, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringVectorAlloc(propvar : *const PROPVARIANT, pprgsz : *mut *mut ::windows_core::PWSTR, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToStringVectorAlloc(propvar, pprgsz, pcelem).ok() +pub unsafe fn PropVariantToStringVectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgsz: *mut *mut ::windows_core::PWSTR, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringVectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgsz : *mut *mut ::windows_core::PWSTR, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToStringVectorAlloc(::core::mem::transmute(propvar), pprgsz, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToStringWithDefault(propvarin: *const PROPVARIANT, pszdefault: P0) -> ::windows_core::PCWSTR +pub unsafe fn PropVariantToStringWithDefault(propvarin: *const ::windows_core::PROPVARIANT, pszdefault: P0) -> ::windows_core::PCWSTR where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringWithDefault(propvarin : *const PROPVARIANT, pszdefault : ::windows_core::PCWSTR) -> ::windows_core::PCWSTR); - PropVariantToStringWithDefault(propvarin, pszdefault.into_param().abi()) + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStringWithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pszdefault : ::windows_core::PCWSTR) -> ::windows_core::PCWSTR); + PropVariantToStringWithDefault(::core::mem::transmute(propvarin), pszdefault.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt16(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16(propvarin : *const PROPVARIANT, puiret : *mut u16) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToUInt16(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, puiret : *mut u16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToUInt16(propvarin, &mut result__).from_abi(result__) + PropVariantToUInt16(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt16Vector(propvar: *const PROPVARIANT, prgn: &mut [u16], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16Vector(propvar : *const PROPVARIANT, prgn : *mut u16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt16Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToUInt16Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [u16], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut u16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt16Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt16VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut u16, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut u16, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt16VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToUInt16VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut u16, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut u16, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt16VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt16WithDefault(propvarin: *const PROPVARIANT, uidefault: u16) -> u16 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16WithDefault(propvarin : *const PROPVARIANT, uidefault : u16) -> u16); - PropVariantToUInt16WithDefault(propvarin, uidefault) +pub unsafe fn PropVariantToUInt16WithDefault(propvarin: *const ::windows_core::PROPVARIANT, uidefault: u16) -> u16 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, uidefault : u16) -> u16); + PropVariantToUInt16WithDefault(::core::mem::transmute(propvarin), uidefault) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt32(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32(propvarin : *const PROPVARIANT, pulret : *mut u32) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToUInt32(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pulret : *mut u32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToUInt32(propvarin, &mut result__).from_abi(result__) + PropVariantToUInt32(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt32Vector(propvar: *const PROPVARIANT, prgn: &mut [u32], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32Vector(propvar : *const PROPVARIANT, prgn : *mut u32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt32Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToUInt32Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [u32], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut u32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt32Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt32VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut u32, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt32VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToUInt32VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut u32, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt32VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt32WithDefault(propvarin: *const PROPVARIANT, uldefault: u32) -> u32 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32WithDefault(propvarin : *const PROPVARIANT, uldefault : u32) -> u32); - PropVariantToUInt32WithDefault(propvarin, uldefault) +pub unsafe fn PropVariantToUInt32WithDefault(propvarin: *const ::windows_core::PROPVARIANT, uldefault: u32) -> u32 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, uldefault : u32) -> u32); + PropVariantToUInt32WithDefault(::core::mem::transmute(propvarin), uldefault) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt64(propvarin: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64(propvarin : *const PROPVARIANT, pullret : *mut u64) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToUInt64(propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pullret : *mut u64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToUInt64(propvarin, &mut result__).from_abi(result__) + PropVariantToUInt64(::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt64Vector(propvar: *const PROPVARIANT, prgn: &mut [u64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64Vector(propvar : *const PROPVARIANT, prgn : *mut u64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt64Vector(propvar, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn PropVariantToUInt64Vector(propvar: *const ::windows_core::PROPVARIANT, prgn: &mut [u64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64Vector(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, prgn : *mut u64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt64Vector(::core::mem::transmute(propvar), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt64VectorAlloc(propvar: *const PROPVARIANT, pprgn: *mut *mut u64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64VectorAlloc(propvar : *const PROPVARIANT, pprgn : *mut *mut u64, pcelem : *mut u32) -> ::windows_core::HRESULT); - PropVariantToUInt64VectorAlloc(propvar, pprgn, pcelem).ok() +pub unsafe fn PropVariantToUInt64VectorAlloc(propvar: *const ::windows_core::PROPVARIANT, pprgn: *mut *mut u64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64VectorAlloc(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pprgn : *mut *mut u64, pcelem : *mut u32) -> ::windows_core::HRESULT); + PropVariantToUInt64VectorAlloc(::core::mem::transmute(propvar), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToUInt64WithDefault(propvarin: *const PROPVARIANT, ulldefault: u64) -> u64 { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64WithDefault(propvarin : *const PROPVARIANT, ulldefault : u64) -> u64); - PropVariantToUInt64WithDefault(propvarin, ulldefault) +pub unsafe fn PropVariantToUInt64WithDefault(propvarin: *const ::windows_core::PROPVARIANT, ulldefault: u64) -> u64 { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64WithDefault(propvarin : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ulldefault : u64) -> u64); + PropVariantToUInt64WithDefault(::core::mem::transmute(propvarin), ulldefault) } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PropVariantToVariant(ppropvar: *const PROPVARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToVariant(ppropvar : *const PROPVARIANT, pvar : *mut super::super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn PropVariantToVariant(ppropvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToVariant(ppropvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PropVariantToVariant(ppropvar, &mut result__).from_abi(result__) + PropVariantToVariant(::core::mem::transmute(ppropvar), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn PropVariantToWinRTPropertyValue(propvar: *const PROPVARIANT) -> ::windows_core::Result +pub unsafe fn PropVariantToWinRTPropertyValue(propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result where T: ::windows_core::Interface, { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToWinRTPropertyValue(propvar : *const PROPVARIANT, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToWinRTPropertyValue(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); let mut result__ = ::std::ptr::null_mut(); - PropVariantToWinRTPropertyValue(propvar, &T::IID, &mut result__).from_abi(result__) + PropVariantToWinRTPropertyValue(::core::mem::transmute(propvar), &T::IID, &mut result__).from_abi(result__) } #[inline] pub unsafe fn ReadClassStg(pstg: P0) -> ::windows_core::Result<::windows_core::GUID> @@ -776,15 +620,13 @@ where ::windows_targets::link!("ole32.dll" "system" fn SetConvertStg(pstg : * mut::core::ffi::c_void, fconvert : super::super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); SetConvertStg(pstg.into_param().abi(), fconvert.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn StgConvertVariantToProperty(pvar: *const PROPVARIANT, codepage: u16, pprop: ::core::option::Option<*mut SERIALIZEDPROPERTYVALUE>, pcb: *mut u32, pid: u32, freserved: P0, pcindirect: ::core::option::Option<*mut u32>) -> *mut SERIALIZEDPROPERTYVALUE +pub unsafe fn StgConvertVariantToProperty(pvar: *const ::windows_core::PROPVARIANT, codepage: u16, pprop: ::core::option::Option<*mut SERIALIZEDPROPERTYVALUE>, pcb: *mut u32, pid: u32, freserved: P0, pcindirect: ::core::option::Option<*mut u32>) -> *mut SERIALIZEDPROPERTYVALUE where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("ole32.dll" "system" fn StgConvertVariantToProperty(pvar : *const PROPVARIANT, codepage : u16, pprop : *mut SERIALIZEDPROPERTYVALUE, pcb : *mut u32, pid : u32, freserved : super::super::super::Foundation:: BOOLEAN, pcindirect : *mut u32) -> *mut SERIALIZEDPROPERTYVALUE); - StgConvertVariantToProperty(pvar, codepage, ::core::mem::transmute(pprop.unwrap_or(::std::ptr::null_mut())), pcb, pid, freserved.into_param().abi(), ::core::mem::transmute(pcindirect.unwrap_or(::std::ptr::null_mut()))) + ::windows_targets::link!("ole32.dll" "system" fn StgConvertVariantToProperty(pvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, codepage : u16, pprop : *mut SERIALIZEDPROPERTYVALUE, pcb : *mut u32, pid : u32, freserved : super::super::super::Foundation:: BOOLEAN, pcindirect : *mut u32) -> *mut SERIALIZEDPROPERTYVALUE); + StgConvertVariantToProperty(::core::mem::transmute(pvar), codepage, ::core::mem::transmute(pprop.unwrap_or(::std::ptr::null_mut())), pcb, pid, freserved.into_param().abi(), ::core::mem::transmute(pcindirect.unwrap_or(::std::ptr::null_mut()))) } #[inline] pub unsafe fn StgCreateDocfile(pwcsname: P0, grfmode: super::STGM, reserved: u32) -> ::windows_core::Result @@ -833,11 +675,9 @@ where ::windows_targets::link!("ole32.dll" "system" fn StgCreateStorageEx(pwcsname : ::windows_core::PCWSTR, grfmode : super:: STGM, stgfmt : STGFMT, grfattrs : u32, pstgoptions : *mut STGOPTIONS, psecuritydescriptor : super::super::super::Security:: PSECURITY_DESCRIPTOR, riid : *const ::windows_core::GUID, ppobjectopen : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); StgCreateStorageEx(pwcsname.into_param().abi(), grfmode, stgfmt, grfattrs, ::core::mem::transmute(pstgoptions.unwrap_or(::std::ptr::null_mut())), psecuritydescriptor.into_param().abi(), riid, ppobjectopen).ok() } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn StgDeserializePropVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbmax: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn StgDeserializePropVariant(pprop : *const SERIALIZEDPROPERTYVALUE, cbmax : u32, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn StgDeserializePropVariant(pprop: *const SERIALIZEDPROPERTYVALUE, cbmax: u32) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn StgDeserializePropVariant(pprop : *const SERIALIZEDPROPERTYVALUE, cbmax : u32, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); StgDeserializePropVariant(pprop, cbmax, &mut result__).from_abi(result__) } @@ -938,12 +778,10 @@ pub unsafe fn StgPropertyLengthAsVariant(pprop: *const SERIALIZEDPROPERTYVALUE, ::windows_targets::link!("ole32.dll" "system" fn StgPropertyLengthAsVariant(pprop : *const SERIALIZEDPROPERTYVALUE, cbprop : u32, codepage : u16, breserved : u8) -> u32); StgPropertyLengthAsVariant(pprop, cbprop, codepage, breserved) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn StgSerializePropVariant(ppropvar: *const PROPVARIANT, ppprop: *mut *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn StgSerializePropVariant(ppropvar : *const PROPVARIANT, ppprop : *mut *mut SERIALIZEDPROPERTYVALUE, pcb : *mut u32) -> ::windows_core::HRESULT); - StgSerializePropVariant(ppropvar, ppprop, pcb).ok() +pub unsafe fn StgSerializePropVariant(ppropvar: *const ::windows_core::PROPVARIANT, ppprop: *mut *mut SERIALIZEDPROPERTYVALUE, pcb: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn StgSerializePropVariant(ppropvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ppprop : *mut *mut SERIALIZEDPROPERTYVALUE, pcb : *mut u32) -> ::windows_core::HRESULT); + StgSerializePropVariant(::core::mem::transmute(ppropvar), ppprop, pcb).ok() } #[inline] pub unsafe fn StgSetTimes(lpszname: P0, pctime: ::core::option::Option<*const super::super::super::Foundation::FILETIME>, patime: ::core::option::Option<*const super::super::super::Foundation::FILETIME>, pmtime: ::core::option::Option<*const super::super::super::Foundation::FILETIME>) -> ::windows_core::Result<()> @@ -953,22 +791,18 @@ where ::windows_targets::link!("ole32.dll" "system" fn StgSetTimes(lpszname : ::windows_core::PCWSTR, pctime : *const super::super::super::Foundation:: FILETIME, patime : *const super::super::super::Foundation:: FILETIME, pmtime : *const super::super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); StgSetTimes(lpszname.into_param().abi(), ::core::mem::transmute(pctime.unwrap_or(::std::ptr::null())), ::core::mem::transmute(patime.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pmtime.unwrap_or(::std::ptr::null()))).ok() } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VariantToPropVariant(pvar: *const super::super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToPropVariant(pvar : *const super::super::Variant:: VARIANT, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VariantToPropVariant(pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::PROPVARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToPropVariant(pvar : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToPropVariant(pvar, &mut result__).from_abi(result__) + VariantToPropVariant(::core::mem::transmute(pvar), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] #[inline] -pub unsafe fn WinRTPropertyValueToPropVariant(punkpropertyvalue: P0) -> ::windows_core::Result +pub unsafe fn WinRTPropertyValueToPropVariant(punkpropertyvalue: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, { - ::windows_targets::link!("propsys.dll" "system" fn WinRTPropertyValueToPropVariant(punkpropertyvalue : * mut::core::ffi::c_void, ppropvar : *mut PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn WinRTPropertyValueToPropVariant(punkpropertyvalue : * mut::core::ffi::c_void, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); WinRTPropertyValueToPropVariant(punkpropertyvalue.into_param().abi(), &mut result__).from_abi(result__) } @@ -1256,52 +1090,42 @@ pub struct IPersistStorage_Vtbl { ::windows_core::imp::com_interface!(IPropertyBag, IPropertyBag_Vtbl, 0x55272a00_42cb_11ce_8135_00aa004bb851); ::windows_core::imp::interface_hierarchy!(IPropertyBag, ::windows_core::IUnknown); impl IPropertyBag { - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IPropertyBag_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *mut super::super::Variant::VARIANT, perrorlog: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Read: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Write: usize, + pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, perrorlog: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyBag2, IPropertyBag2_Vtbl, 0x22f55882_280b_11d0_a8a9_00a0c90c2004); ::windows_core::imp::interface_hierarchy!(IPropertyBag2, ::windows_core::IUnknown); impl IPropertyBag2 { - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: P0, pvarvalue: *mut super::super::Variant::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] + pub unsafe fn Read(&self, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: P0, pvarvalue: *mut ::windows_core::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), cproperties, ppropbag, perrlog.into_param().abi(), pvarvalue, phrerror).ok() + (::windows_core::Interface::vtable(self).Read)(::windows_core::Interface::as_raw(self), cproperties, ppropbag, perrlog.into_param().abi(), ::core::mem::transmute(pvarvalue), phrerror).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), cproperties, ppropbag, pvarvalue).ok() + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] + pub unsafe fn Write(&self, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Write)(::windows_core::Interface::as_raw(self), cproperties, ppropbag, ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn CountProperties(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1325,13 +1149,13 @@ impl IPropertyBag2 { #[doc(hidden)] pub struct IPropertyBag2_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::Variant::VARIANT, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Variant")] + pub Read: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, perrlog: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, phrerror: *mut ::windows_core::HRESULT) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Variant"))] Read: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Variant")] + pub Write: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cproperties: u32, ppropbag: *const PROPBAG2, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Variant"))] Write: usize, pub CountProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcproperties: *mut u32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Variant")] @@ -1371,15 +1195,11 @@ pub struct IPropertySetStorage_Vtbl { ::windows_core::imp::com_interface!(IPropertyStorage, IPropertyStorage_Vtbl, 0x00000138_0000_0000_c000_000000000046); ::windows_core::imp::interface_hierarchy!(IPropertyStorage, ::windows_core::IUnknown); impl IPropertyStorage { - #[doc = "Required features: `\"Win32_System_Variant\"`"] - #[cfg(feature = "Win32_System_Variant")] - pub unsafe fn ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ReadMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgpropvar).ok() + pub unsafe fn ReadMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ReadMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, ::core::mem::transmute(rgpropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Variant\"`"] - #[cfg(feature = "Win32_System_Variant")] - pub unsafe fn WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).WriteMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, rgpropvar, propidnamefirst).ok() + pub unsafe fn WriteMultiple(&self, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const ::windows_core::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).WriteMultiple)(::windows_core::Interface::as_raw(self), cpspec, rgpspec, ::core::mem::transmute(rgpropvar), propidnamefirst).ok() } pub unsafe fn DeleteMultiple(&self, rgpspec: &[PROPSPEC]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeleteMultiple)(::windows_core::Interface::as_raw(self), rgpspec.len().try_into().unwrap(), ::core::mem::transmute(rgpspec.as_ptr())).ok() @@ -1417,14 +1237,8 @@ impl IPropertyStorage { #[doc(hidden)] pub struct IPropertyStorage_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(feature = "Win32_System_Variant")] - pub ReadMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(feature = "Win32_System_Variant"))] - ReadMultiple: usize, - #[cfg(feature = "Win32_System_Variant")] - pub WriteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const PROPVARIANT, propidnamefirst: u32) -> ::windows_core::HRESULT, - #[cfg(not(feature = "Win32_System_Variant"))] - WriteMultiple: usize, + pub ReadMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub WriteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC, rgpropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propidnamefirst: u32) -> ::windows_core::HRESULT, pub DeleteMultiple: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpspec: u32, rgpspec: *const PROPSPEC) -> ::windows_core::HRESULT, pub ReadPropertyNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropid: u32, rgpropid: *const u32, rglpwstrname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub WritePropertyNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropid: u32, rgpropid: *const u32, rglpwstrname: *const ::windows_core::PCWSTR) -> ::windows_core::HRESULT, @@ -2318,39 +2132,30 @@ impl ::core::default::Default for CALPWSTR { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] pub struct CAPROPVARIANT { pub cElems: u32, - pub pElems: *mut PROPVARIANT, + pub pElems: *mut ::windows_core::PROPVARIANT, } -#[cfg(feature = "Win32_System_Variant")] impl ::core::marker::Copy for CAPROPVARIANT {} -#[cfg(feature = "Win32_System_Variant")] impl ::core::clone::Clone for CAPROPVARIANT { fn clone(&self) -> Self { *self } } -#[cfg(feature = "Win32_System_Variant")] impl ::core::fmt::Debug for CAPROPVARIANT { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("CAPROPVARIANT").field("cElems", &self.cElems).field("pElems", &self.pElems).finish() } } -#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::TypeKind for CAPROPVARIANT { type TypeKind = ::windows_core::CopyType; } -#[cfg(feature = "Win32_System_Variant")] impl ::core::cmp::PartialEq for CAPROPVARIANT { fn eq(&self, other: &Self) -> bool { self.cElems == other.cElems && self.pElems == other.pElems } } -#[cfg(feature = "Win32_System_Variant")] impl ::core::cmp::Eq for CAPROPVARIANT {} -#[cfg(feature = "Win32_System_Variant")] impl ::core::default::Default for CAPROPVARIANT { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -2678,171 +2483,6 @@ impl ::core::default::Default for PROPSPEC_0 { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] -pub struct PROPVARIANT { - pub Anonymous: PROPVARIANT_0, -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::clone::Clone for PROPVARIANT { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(feature = "Win32_System_Variant")] -impl ::windows_core::TypeKind for PROPVARIANT { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::default::Default for PROPVARIANT { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] -pub union PROPVARIANT_0 { - pub Anonymous: ::std::mem::ManuallyDrop, - pub decVal: super::super::super::Foundation::DECIMAL, -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::clone::Clone for PROPVARIANT_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(feature = "Win32_System_Variant")] -impl ::windows_core::TypeKind for PROPVARIANT_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::default::Default for PROPVARIANT_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] -pub struct PROPVARIANT_0_0 { - pub vt: super::super::Variant::VARENUM, - pub wReserved1: u16, - pub wReserved2: u16, - pub wReserved3: u16, - pub Anonymous: PROPVARIANT_0_0_0, -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::clone::Clone for PROPVARIANT_0_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(feature = "Win32_System_Variant")] -impl ::windows_core::TypeKind for PROPVARIANT_0_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::default::Default for PROPVARIANT_0_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Variant\"`"] -#[cfg(feature = "Win32_System_Variant")] -pub union PROPVARIANT_0_0_0 { - pub cVal: i8, - pub bVal: u8, - pub iVal: i16, - pub uiVal: u16, - pub lVal: i32, - pub ulVal: u32, - pub intVal: i32, - pub uintVal: u32, - pub hVal: i64, - pub uhVal: u64, - pub fltVal: f32, - pub dblVal: f64, - pub boolVal: super::super::super::Foundation::VARIANT_BOOL, - pub __OBSOLETE__VARIANT_BOOL: super::super::super::Foundation::VARIANT_BOOL, - pub scode: i32, - pub cyVal: super::CY, - pub date: f64, - pub filetime: super::super::super::Foundation::FILETIME, - pub puuid: *mut ::windows_core::GUID, - pub pclipdata: *mut CLIPDATA, - pub bstrVal: ::std::mem::ManuallyDrop<::windows_core::BSTR>, - pub bstrblobVal: BSTRBLOB, - pub blob: super::BLOB, - pub pszVal: ::windows_core::PSTR, - pub pwszVal: ::windows_core::PWSTR, - pub punkVal: ::std::mem::ManuallyDrop<::core::option::Option<::windows_core::IUnknown>>, - pub pdispVal: ::std::mem::ManuallyDrop<::core::option::Option>, - pub pStream: ::std::mem::ManuallyDrop<::core::option::Option>, - pub pStorage: ::std::mem::ManuallyDrop<::core::option::Option>, - pub pVersionedStream: *mut VERSIONEDSTREAM, - pub parray: *mut super::SAFEARRAY, - pub cac: CAC, - pub caub: CAUB, - pub cai: CAI, - pub caui: CAUI, - pub cal: CAL, - pub caul: CAUL, - pub cah: CAH, - pub cauh: CAUH, - pub caflt: CAFLT, - pub cadbl: CADBL, - pub cabool: CABOOL, - pub cascode: CASCODE, - pub cacy: CACY, - pub cadate: CADATE, - pub cafiletime: CAFILETIME, - pub cauuid: CACLSID, - pub caclipdata: CACLIPDATA, - pub cabstr: CABSTR, - pub cabstrblob: CABSTRBLOB, - pub calpstr: CALPSTR, - pub calpwstr: CALPWSTR, - pub capropvar: CAPROPVARIANT, - pub pcVal: ::windows_core::PSTR, - pub pbVal: *mut u8, - pub piVal: *mut i16, - pub puiVal: *mut u16, - pub plVal: *mut i32, - pub pulVal: *mut u32, - pub pintVal: *mut i32, - pub puintVal: *mut u32, - pub pfltVal: *mut f32, - pub pdblVal: *mut f64, - pub pboolVal: *mut super::super::super::Foundation::VARIANT_BOOL, - pub pdecVal: *mut super::super::super::Foundation::DECIMAL, - pub pscode: *mut i32, - pub pcyVal: *mut super::CY, - pub pdate: *mut f64, - pub pbstrVal: *mut ::windows_core::BSTR, - pub ppunkVal: *mut ::core::option::Option<::windows_core::IUnknown>, - pub ppdispVal: *mut ::core::option::Option, - pub pparray: *mut *mut super::SAFEARRAY, - pub pvarVal: *mut PROPVARIANT, -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::clone::Clone for PROPVARIANT_0_0_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(feature = "Win32_System_Variant")] -impl ::windows_core::TypeKind for PROPVARIANT_0_0_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(feature = "Win32_System_Variant")] -impl ::core::default::Default for PROPVARIANT_0_0_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] pub struct RemSNB { pub ulCntStr: u32, pub ulCntChar: u32, diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Com/impl.rs index 48f358baed..de3398e75f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/impl.rs @@ -1628,17 +1628,13 @@ impl IDataObject_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDispatch_Impl: Sized { fn GetTypeInfoCount(&self) -> ::windows_core::Result; fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows_core::Result; fn GetIDsOfNames(&self, riid: *const ::windows_core::GUID, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows_core::Result<()>; - fn Invoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn Invoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDispatch {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDispatch_Vtbl { pub const fn new, Impl: IDispatch_Impl, const OFFSET: isize>() -> IDispatch_Vtbl { unsafe extern "system" fn GetTypeInfoCount, Impl: IDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pctinfo: *mut u32) -> ::windows_core::HRESULT { @@ -1668,7 +1664,7 @@ impl IDispatch_Vtbl { let this = (*this).get_impl(); this.GetIDsOfNames(::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&rgsznames), ::core::mem::transmute_copy(&cnames), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&rgdispid)).into() } - unsafe extern "system" fn Invoke, Impl: IDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Invoke, Impl: IDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Invoke(::core::mem::transmute_copy(&dispidmember), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() @@ -4224,7 +4220,7 @@ pub trait ITypeInfo_Impl: Sized { fn GetRefTypeOfImplType(&self, index: u32) -> ::windows_core::Result; fn GetImplTypeFlags(&self, index: u32) -> ::windows_core::Result; fn GetIDsOfNames(&self, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, pmemid: *mut i32) -> ::windows_core::Result<()>; - fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; fn GetDocumentation(&self, memid: i32, pbstrname: *mut ::windows_core::BSTR, pbstrdocstring: *mut ::windows_core::BSTR, pdwhelpcontext: *mut u32, pbstrhelpfile: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetDllEntry(&self, memid: i32, invkind: INVOKEKIND, pbstrdllname: *mut ::windows_core::BSTR, pbstrname: *mut ::windows_core::BSTR, pwordinal: *mut u16) -> ::windows_core::Result<()>; fn GetRefTypeInfo(&self, hreftype: u32) -> ::windows_core::Result; @@ -4317,7 +4313,7 @@ impl ITypeInfo_Vtbl { let this = (*this).get_impl(); this.GetIDsOfNames(::core::mem::transmute_copy(&rgsznames), ::core::mem::transmute_copy(&cnames), ::core::mem::transmute_copy(&pmemid)).into() } - unsafe extern "system" fn Invoke, Impl: ITypeInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Invoke, Impl: ITypeInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Invoke(::core::mem::transmute_copy(&pvinstance), ::core::mem::transmute_copy(&memid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() @@ -4418,11 +4414,11 @@ pub trait ITypeInfo2_Impl: Sized + ITypeInfo_Impl { fn GetTypeFlags(&self) -> ::windows_core::Result; fn GetFuncIndexOfMemId(&self, memid: i32, invkind: INVOKEKIND) -> ::windows_core::Result; fn GetVarIndexOfMemId(&self, memid: i32) -> ::windows_core::Result; - fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result; - fn GetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetDocumentation2(&self, memid: i32, lcid: u32, pbstrhelpstring: *mut ::windows_core::BSTR, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetAllCustData(&self) -> ::windows_core::Result; fn GetAllFuncCustData(&self, index: u32) -> ::windows_core::Result; @@ -4479,7 +4475,7 @@ impl ITypeInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCustData(::core::mem::transmute_copy(&guid)) { @@ -4490,7 +4486,7 @@ impl ITypeInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetFuncCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFuncCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFuncCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid)) { @@ -4501,7 +4497,7 @@ impl ITypeInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetParamCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParamCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParamCustData(::core::mem::transmute_copy(&indexfunc), ::core::mem::transmute_copy(&indexparam), ::core::mem::transmute_copy(&guid)) { @@ -4512,7 +4508,7 @@ impl ITypeInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetVarCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetVarCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetVarCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid)) { @@ -4523,7 +4519,7 @@ impl ITypeInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetImplTypeCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetImplTypeCustData, Impl: ITypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetImplTypeCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid)) { @@ -4730,20 +4726,16 @@ impl ITypeLib_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITypeLib2_Impl: Sized + ITypeLib_Impl { - fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetLibStatistics(&self, pcuniquenames: *mut u32, pcchuniquenames: *mut u32) -> ::windows_core::Result<()>; fn GetDocumentation2(&self, index: i32, lcid: u32, pbstrhelpstring: *mut ::windows_core::BSTR, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetAllCustData(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITypeLib2 {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITypeLib2_Vtbl { pub const fn new, Impl: ITypeLib2_Impl, const OFFSET: isize>() -> ITypeLib2_Vtbl { - unsafe extern "system" fn GetCustData, Impl: ITypeLib2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCustData, Impl: ITypeLib2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCustData(::core::mem::transmute_copy(&guid)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/Com/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Com/mod.rs index 49acc7d6b4..63567859db 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Com/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Com/mod.rs @@ -2021,9 +2021,7 @@ impl IDispatch { pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows_core::GUID, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetIDsOfNames)(::windows_core::Interface::as_raw(self), riid, rgsznames, cnames, lcid, rgdispid).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: ::core::option::Option<*mut super::Variant::VARIANT>, pexcepinfo: ::core::option::Option<*mut EXCEPINFO>, puargerr: ::core::option::Option<*mut u32>) -> ::windows_core::Result<()> { + pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: ::core::option::Option<*mut ::windows_core::VARIANT>, pexcepinfo: ::core::option::Option<*mut EXCEPINFO>, puargerr: ::core::option::Option<*mut u32>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Invoke)(::windows_core::Interface::as_raw(self), dispidmember, riid, lcid, wflags, pdispparams, ::core::mem::transmute(pvarresult.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pexcepinfo.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(puargerr.unwrap_or(::std::ptr::null_mut()))).ok() } } @@ -2034,10 +2032,7 @@ pub struct IDispatch_Vtbl { pub GetTypeInfoCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pctinfo: *mut u32) -> ::windows_core::HRESULT, pub GetTypeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itinfo: u32, lcid: u32, pptinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetIDsOfNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Invoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Invoke: usize, + pub Invoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, riid: *const ::windows_core::GUID, lcid: u32, wflags: DISPATCH_FLAGS, pdispparams: *const DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IEnumCATEGORYINFO, IEnumCATEGORYINFO_Vtbl, 0x0002e011_0000_0000_c000_000000000046); ::windows_core::imp::interface_hierarchy!(IEnumCATEGORYINFO, ::windows_core::IUnknown); @@ -3848,10 +3843,8 @@ impl ITypeInfo { pub unsafe fn GetIDsOfNames(&self, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, pmemid: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetIDsOfNames)(::windows_core::Interface::as_raw(self), rgsznames, cnames, pmemid).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Invoke)(::windows_core::Interface::as_raw(self), pvinstance, memid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + pub unsafe fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Invoke)(::windows_core::Interface::as_raw(self), pvinstance, memid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } pub unsafe fn GetDocumentation(&self, memid: i32, pbstrname: ::core::option::Option<*mut ::windows_core::BSTR>, pbstrdocstring: ::core::option::Option<*mut ::windows_core::BSTR>, pdwhelpcontext: *mut u32, pbstrhelpfile: ::core::option::Option<*mut ::windows_core::BSTR>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetDocumentation)(::windows_core::Interface::as_raw(self), memid, ::core::mem::transmute(pbstrname.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pbstrdocstring.unwrap_or(::std::ptr::null_mut())), pdwhelpcontext, ::core::mem::transmute(pbstrhelpfile.unwrap_or(::std::ptr::null_mut()))).ok() @@ -3918,10 +3911,7 @@ pub struct ITypeInfo_Vtbl { pub GetRefTypeOfImplType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, preftype: *mut u32) -> ::windows_core::HRESULT, pub GetImplTypeFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pimpltypeflags: *mut IMPLTYPEFLAGS) -> ::windows_core::HRESULT, pub GetIDsOfNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, pmemid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Invoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Invoke: usize, + pub Invoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, pub GetDocumentation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrdocstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwhelpcontext: *mut u32, pbstrhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetDllEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32, invkind: INVOKEKIND, pbstrdllname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pwordinal: *mut u16) -> ::windows_core::HRESULT, pub GetRefTypeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hreftype: u32, pptinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3981,10 +3971,8 @@ impl ITypeInfo2 { pub unsafe fn GetIDsOfNames(&self, rgsznames: *const ::windows_core::PCWSTR, cnames: u32, pmemid: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetIDsOfNames)(::windows_core::Interface::as_raw(self), rgsznames, cnames, pmemid).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Invoke)(::windows_core::Interface::as_raw(self), pvinstance, memid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + pub unsafe fn Invoke(&self, pvinstance: *const ::core::ffi::c_void, memid: i32, wflags: DISPATCH_FLAGS, pdispparams: *mut DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Invoke)(::windows_core::Interface::as_raw(self), pvinstance, memid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } pub unsafe fn GetDocumentation(&self, memid: i32, pbstrname: ::core::option::Option<*mut ::windows_core::BSTR>, pbstrdocstring: ::core::option::Option<*mut ::windows_core::BSTR>, pdwhelpcontext: *mut u32, pbstrhelpfile: ::core::option::Option<*mut ::windows_core::BSTR>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetDocumentation)(::windows_core::Interface::as_raw(self), memid, ::core::mem::transmute(pbstrname.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pbstrdocstring.unwrap_or(::std::ptr::null_mut())), pdwhelpcontext, ::core::mem::transmute(pbstrhelpfile.unwrap_or(::std::ptr::null_mut()))).ok() @@ -4045,65 +4033,45 @@ impl ITypeInfo2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetVarIndexOfMemId)(::windows_core::Interface::as_raw(self), memid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCustData)(::windows_core::Interface::as_raw(self), guid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFuncCustData)(::windows_core::Interface::as_raw(self), index, guid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetParamCustData)(::windows_core::Interface::as_raw(self), indexfunc, indexparam, guid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetVarCustData)(::windows_core::Interface::as_raw(self), index, guid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetImplTypeCustData)(::windows_core::Interface::as_raw(self), index, guid, &mut result__).from_abi(result__) } pub unsafe fn GetDocumentation2(&self, memid: i32, lcid: u32, pbstrhelpstring: ::core::option::Option<*mut ::windows_core::BSTR>, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: ::core::option::Option<*mut ::windows_core::BSTR>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetDocumentation2)(::windows_core::Interface::as_raw(self), memid, lcid, ::core::mem::transmute(pbstrhelpstring.unwrap_or(::std::ptr::null_mut())), pdwhelpstringcontext, ::core::mem::transmute(pbstrhelpstringdll.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllCustData(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllCustData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllFuncCustData(&self, index: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllFuncCustData)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllParamCustData(&self, indexfunc: u32, indexparam: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllParamCustData)(::windows_core::Interface::as_raw(self), indexfunc, indexparam, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllVarCustData(&self, index: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllVarCustData)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllImplTypeCustData(&self, index: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllImplTypeCustData)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) @@ -4117,47 +4085,17 @@ pub struct ITypeInfo2_Vtbl { pub GetTypeFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptypeflags: *mut u32) -> ::windows_core::HRESULT, pub GetFuncIndexOfMemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32, invkind: INVOKEKIND, pfuncindex: *mut u32) -> ::windows_core::HRESULT, pub GetVarIndexOfMemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32, pvarindex: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFuncCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFuncCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetParamCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetParamCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetVarCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetVarCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetImplTypeCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetImplTypeCustData: usize, + pub GetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetFuncCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetParamCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetVarCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetImplTypeCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetDocumentation2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32, lcid: u32, pbstrhelpstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllFuncCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllFuncCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllParamCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllParamCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllVarCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllVarCustData: usize, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllImplTypeCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllImplTypeCustData: usize, } ::windows_core::imp::com_interface!(ITypeLib, ITypeLib_Vtbl, 0x00020402_0000_0000_c000_000000000046); ::windows_core::imp::interface_hierarchy!(ITypeLib, ::windows_core::IUnknown); @@ -4251,9 +4189,7 @@ impl ITypeLib2 { pub unsafe fn ReleaseTLibAttr(&self, ptlibattr: *const TLIBATTR) { (::windows_core::Interface::vtable(self).base__.ReleaseTLibAttr)(::windows_core::Interface::as_raw(self), ptlibattr) } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetCustData(&self, guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCustData)(::windows_core::Interface::as_raw(self), guid, &mut result__).from_abi(result__) } @@ -4263,8 +4199,6 @@ impl ITypeLib2 { pub unsafe fn GetDocumentation2(&self, index: i32, lcid: u32, pbstrhelpstring: ::core::option::Option<*mut ::windows_core::BSTR>, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: ::core::option::Option<*mut ::windows_core::BSTR>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetDocumentation2)(::windows_core::Interface::as_raw(self), index, lcid, ::core::mem::transmute(pbstrhelpstring.unwrap_or(::std::ptr::null_mut())), pdwhelpstringcontext, ::core::mem::transmute(pbstrhelpstringdll.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetAllCustData(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAllCustData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) @@ -4274,16 +4208,10 @@ impl ITypeLib2 { #[doc(hidden)] pub struct ITypeLib2_Vtbl { pub base__: ITypeLib_Vtbl, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCustData: usize, + pub GetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetLibStatistics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcuniquenames: *mut u32, pcchuniquenames: *mut u32) -> ::windows_core::HRESULT, pub GetDocumentation2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, lcid: u32, pbstrhelpstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwhelpstringcontext: *mut u32, pbstrhelpstringdll: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetAllCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcustdata: *mut CUSTDATA) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAllCustData: usize, } ::windows_core::imp::com_interface!(ITypeLibRegistration, ITypeLibRegistration_Vtbl, 0x76a3e735_02df_4a12_98eb_043ad3600af3); ::windows_core::imp::interface_hierarchy!(ITypeLibRegistration, ::windows_core::IUnknown); @@ -6757,62 +6685,59 @@ impl ::core::default::Default for CSPLATFORM { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct CUSTDATA { pub cCustData: u32, pub prgCustData: *mut CUSTDATAITEM, } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for CUSTDATA {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for CUSTDATA { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for CUSTDATA { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("CUSTDATA").field("cCustData", &self.cCustData).field("prgCustData", &self.prgCustData).finish() } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for CUSTDATA { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for CUSTDATA { fn eq(&self, other: &Self) -> bool { self.cCustData == other.cCustData && self.prgCustData == other.prgCustData } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for CUSTDATA {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for CUSTDATA { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct CUSTDATAITEM { pub guid: ::windows_core::GUID, - pub varValue: super::Variant::VARIANT, + pub varValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for CUSTDATAITEM { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for CUSTDATAITEM { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("CUSTDATAITEM").field("guid", &self.guid).field("varValue", &self.varValue).finish() + } +} impl ::windows_core::TypeKind for CUSTDATAITEM { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for CUSTDATAITEM { + fn eq(&self, other: &Self) -> bool { + self.guid == other.guid && self.varValue == other.varValue + } +} +impl ::core::cmp::Eq for CUSTDATAITEM {} impl ::core::default::Default for CUSTDATAITEM { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -6929,41 +6854,32 @@ impl ::core::default::Default for ContextProperty { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct DISPPARAMS { - pub rgvarg: *mut super::Variant::VARIANT, + pub rgvarg: *mut ::windows_core::VARIANT, pub rgdispidNamedArgs: *mut i32, pub cArgs: u32, pub cNamedArgs: u32, } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for DISPPARAMS {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for DISPPARAMS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for DISPPARAMS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("DISPPARAMS").field("rgvarg", &self.rgvarg).field("rgdispidNamedArgs", &self.rgdispidNamedArgs).field("cArgs", &self.cArgs).field("cNamedArgs", &self.cNamedArgs).finish() } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for DISPPARAMS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for DISPPARAMS { fn eq(&self, other: &Self) -> bool { self.rgvarg == other.rgvarg && self.rgdispidNamedArgs == other.rgdispidNamedArgs && self.cArgs == other.cArgs && self.cNamedArgs == other.cNamedArgs } } -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for DISPPARAMS {} -#[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for DISPPARAMS { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -8097,7 +8013,7 @@ impl ::core::default::Default for VARDESC { #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub union VARDESC_0 { pub oInst: u32, - pub lpvarValue: *mut super::Variant::VARIANT, + pub lpvarValue: *mut ::windows_core::VARIANT, } #[cfg(all(feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for VARDESC_0 {} diff --git a/crates/libs/windows/src/Windows/Win32/System/ComponentServices/impl.rs b/crates/libs/windows/src/Windows/Win32/System/ComponentServices/impl.rs index fa6fa9b857..a1726d5a7e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/ComponentServices/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/ComponentServices/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ContextInfo_Impl: Sized + super::Com::IDispatch_Impl { fn IsInTransaction(&self) -> ::windows_core::Result; fn GetTransaction(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -7,9 +7,9 @@ pub trait ContextInfo_Impl: Sized + super::Com::IDispatch_Impl { fn GetActivityId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetContextId(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ContextInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ContextInfo_Vtbl { pub const fn new, Impl: ContextInfo_Impl, const OFFSET: isize>() -> ContextInfo_Vtbl { unsafe extern "system" fn IsInTransaction, Impl: ContextInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbisintx: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -80,16 +80,16 @@ impl ContextInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ContextInfo2_Impl: Sized + ContextInfo_Impl { fn GetPartitionId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetApplicationId(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetApplicationInstanceId(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ContextInfo2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ContextInfo2_Vtbl { pub const fn new, Impl: ContextInfo2_Impl, const OFFSET: isize>() -> ContextInfo2_Vtbl { unsafe extern "system" fn GetPartitionId, Impl: ContextInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, __midl__contextinfo20000: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -136,15 +136,15 @@ impl ContextInfo2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAppDomainHelper_Impl: Sized + super::Com::IDispatch_Impl { fn Initialize(&self, punkad: ::core::option::Option<&::windows_core::IUnknown>, __midl__iappdomainhelper0000: isize, ppool: *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn DoCallback(&self, punkad: ::core::option::Option<&::windows_core::IUnknown>, __midl__iappdomainhelper0001: isize, ppool: *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAppDomainHelper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAppDomainHelper_Vtbl { pub const fn new, Impl: IAppDomainHelper_Impl, const OFFSET: isize>() -> IAppDomainHelper_Vtbl { unsafe extern "system" fn Initialize, Impl: IAppDomainHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkad: *mut ::core::ffi::c_void, __midl__iappdomainhelper0000: isize, ppool: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -167,14 +167,14 @@ impl IAppDomainHelper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAssemblyLocator_Impl: Sized + super::Com::IDispatch_Impl { fn GetModules(&self, applicationdir: &::windows_core::BSTR, applicationname: &::windows_core::BSTR, assemblyname: &::windows_core::BSTR) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAssemblyLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAssemblyLocator_Vtbl { pub const fn new, Impl: IAssemblyLocator_Impl, const OFFSET: isize>() -> IAssemblyLocator_Vtbl { unsafe extern "system" fn GetModules, Impl: IAssemblyLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, applicationdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, applicationname: ::std::mem::MaybeUninit<::windows_core::BSTR>, assemblyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pmodules: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -211,8 +211,8 @@ impl IAsyncErrorNotify_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICOMAdminCatalog_Impl: Sized + super::Com::IDispatch_Impl { fn GetCollection(&self, bstrcollname: &::windows_core::BSTR) -> ::windows_core::Result; fn Connect(&self, bstrcatalogservername: &::windows_core::BSTR) -> ::windows_core::Result; @@ -241,9 +241,9 @@ pub trait ICOMAdminCatalog_Impl: Sized + super::Com::IDispatch_Impl { fn InstallEventClass(&self, bstrapplidorname: &::windows_core::BSTR, bstrdll: &::windows_core::BSTR, bstrtlb: &::windows_core::BSTR, bstrpsdll: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetEventClassesForIID(&self, bstriid: &::windows_core::BSTR, ppsavarclsids: *mut *mut super::Com::SAFEARRAY, ppsavarprogids: *mut *mut super::Com::SAFEARRAY, ppsavardescriptions: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICOMAdminCatalog {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICOMAdminCatalog_Vtbl { pub const fn new, Impl: ICOMAdminCatalog_Impl, const OFFSET: isize>() -> ICOMAdminCatalog_Vtbl { unsafe extern "system" fn GetCollection, Impl: ICOMAdminCatalog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -446,16 +446,16 @@ impl ICOMAdminCatalog_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICOMAdminCatalog2_Impl: Sized + ICOMAdminCatalog_Impl { - fn GetCollectionByQuery2(&self, bstrcollectionname: &::windows_core::BSTR, pvarquerystrings: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn GetCollectionByQuery2(&self, bstrcollectionname: &::windows_core::BSTR, pvarquerystrings: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn GetApplicationInstanceIDFromProcessID(&self, lprocessid: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn ShutdownApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PauseApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ResumeApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn RecycleApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT, lreasoncode: i32) -> ::windows_core::Result<()>; - fn AreApplicationInstancesPaused(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ShutdownApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PauseApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ResumeApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn RecycleApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT, lreasoncode: i32) -> ::windows_core::Result<()>; + fn AreApplicationInstancesPaused(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn DumpApplicationInstance(&self, bstrapplicationinstanceid: &::windows_core::BSTR, bstrdirectory: &::windows_core::BSTR, lmaximages: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn IsApplicationInstanceDumpSupported(&self) -> ::windows_core::Result; fn CreateServiceForApplication(&self, bstrapplicationidorname: &::windows_core::BSTR, bstrservicename: &::windows_core::BSTR, bstrstarttype: &::windows_core::BSTR, bstrerrorcontrol: &::windows_core::BSTR, bstrdependencies: &::windows_core::BSTR, bstrrunas: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, bdesktopok: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -467,26 +467,26 @@ pub trait ICOMAdminCatalog2_Impl: Sized + ICOMAdminCatalog_Impl { fn CurrentPartitionName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GlobalPartitionID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FlushPartitionCache(&self) -> ::windows_core::Result<()>; - fn CopyApplications(&self, bstrsourcepartitionidorname: &::windows_core::BSTR, pvarapplicationid: *const super::Variant::VARIANT, bstrdestinationpartitionidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn CopyComponents(&self, bstrsourceapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn MoveComponents(&self, bstrsourceapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn CopyApplications(&self, bstrsourcepartitionidorname: &::windows_core::BSTR, pvarapplicationid: *const ::windows_core::VARIANT, bstrdestinationpartitionidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn CopyComponents(&self, bstrsourceapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const ::windows_core::VARIANT, bstrdestinationapplicationidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn MoveComponents(&self, bstrsourceapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const ::windows_core::VARIANT, bstrdestinationapplicationidorname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AliasComponent(&self, bstrsrcapplicationidorname: &::windows_core::BSTR, bstrclsidorprogid: &::windows_core::BSTR, bstrdestapplicationidorname: &::windows_core::BSTR, bstrnewprogid: &::windows_core::BSTR, bstrnewclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsSafeToDelete(&self, bstrdllname: &::windows_core::BSTR) -> ::windows_core::Result; - fn ImportUnconfiguredComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PromoteUnconfiguredComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ImportComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ImportUnconfiguredComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PromoteUnconfiguredComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ImportComponents(&self, bstrapplicationidorname: &::windows_core::BSTR, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Is64BitCatalogServer(&self) -> ::windows_core::Result; fn ExportPartition(&self, bstrpartitionidorname: &::windows_core::BSTR, bstrpartitionfilename: &::windows_core::BSTR, loptions: COMAdminApplicationExportOptions) -> ::windows_core::Result<()>; fn InstallPartition(&self, bstrfilename: &::windows_core::BSTR, bstrdestdirectory: &::windows_core::BSTR, loptions: COMAdminApplicationInstallOptions, bstruserid: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, bstrrsn: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn QueryApplicationFile2(&self, bstrapplicationfile: &::windows_core::BSTR) -> ::windows_core::Result; fn GetComponentVersionCount(&self, bstrclsidorprogid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICOMAdminCatalog2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICOMAdminCatalog2_Vtbl { pub const fn new, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>() -> ICOMAdminCatalog2_Vtbl { - unsafe extern "system" fn GetCollectionByQuery2, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollectionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarquerystrings: *const super::Variant::VARIANT, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCollectionByQuery2, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollectionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarquerystrings: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCollectionByQuery2(::core::mem::transmute(&bstrcollectionname), ::core::mem::transmute_copy(&pvarquerystrings)) { @@ -508,27 +508,27 @@ impl ICOMAdminCatalog2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ShutdownApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ShutdownApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ShutdownApplicationInstances(::core::mem::transmute_copy(&pvarapplicationinstanceid)).into() } - unsafe extern "system" fn PauseApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PauseApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PauseApplicationInstances(::core::mem::transmute_copy(&pvarapplicationinstanceid)).into() } - unsafe extern "system" fn ResumeApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ResumeApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ResumeApplicationInstances(::core::mem::transmute_copy(&pvarapplicationinstanceid)).into() } - unsafe extern "system" fn RecycleApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT, lreasoncode: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn RecycleApplicationInstances, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lreasoncode: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RecycleApplicationInstances(::core::mem::transmute_copy(&pvarapplicationinstanceid), ::core::mem::transmute_copy(&lreasoncode)).into() } - unsafe extern "system" fn AreApplicationInstancesPaused, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT, pvarboolpaused: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn AreApplicationInstancesPaused, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarboolpaused: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AreApplicationInstancesPaused(::core::mem::transmute_copy(&pvarapplicationinstanceid)) { @@ -636,17 +636,17 @@ impl ICOMAdminCatalog2_Vtbl { let this = (*this).get_impl(); this.FlushPartitionCache().into() } - unsafe extern "system" fn CopyApplications, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourcepartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarapplicationid: *const super::Variant::VARIANT, bstrdestinationpartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyApplications, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourcepartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarapplicationid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationpartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CopyApplications(::core::mem::transmute(&bstrsourcepartitionidorname), ::core::mem::transmute_copy(&pvarapplicationid), ::core::mem::transmute(&bstrdestinationpartitionidorname)).into() } - unsafe extern "system" fn CopyComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CopyComponents(::core::mem::transmute(&bstrsourceapplicationidorname), ::core::mem::transmute_copy(&pvarclsidorprogid), ::core::mem::transmute(&bstrdestinationapplicationidorname)).into() } - unsafe extern "system" fn MoveComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.MoveComponents(::core::mem::transmute(&bstrsourceapplicationidorname), ::core::mem::transmute_copy(&pvarclsidorprogid), ::core::mem::transmute(&bstrdestinationapplicationidorname)).into() @@ -667,17 +667,17 @@ impl ICOMAdminCatalog2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ImportUnconfiguredComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportUnconfiguredComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ImportUnconfiguredComponents(::core::mem::transmute(&bstrapplicationidorname), ::core::mem::transmute_copy(&pvarclsidorprogid), ::core::mem::transmute_copy(&pvarcomponenttype)).into() } - unsafe extern "system" fn PromoteUnconfiguredComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PromoteUnconfiguredComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PromoteUnconfiguredComponents(::core::mem::transmute(&bstrapplicationidorname), ::core::mem::transmute_copy(&pvarclsidorprogid), ::core::mem::transmute_copy(&pvarcomponenttype)).into() } - unsafe extern "system" fn ImportComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ImportComponents, Impl: ICOMAdminCatalog2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ImportComponents(::core::mem::transmute(&bstrapplicationidorname), ::core::mem::transmute_copy(&pvarclsidorprogid), ::core::mem::transmute_copy(&pvarcomponenttype)).into() @@ -805,8 +805,8 @@ impl ICOMLBArguments_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICatalogCollection_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, lindex: i32) -> ::windows_core::Result; @@ -815,8 +815,8 @@ pub trait ICatalogCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Add(&self) -> ::windows_core::Result; fn Populate(&self) -> ::windows_core::Result<()>; fn SaveChanges(&self) -> ::windows_core::Result; - fn GetCollection(&self, bstrcollname: &::windows_core::BSTR, varobjectkey: &super::Variant::VARIANT) -> ::windows_core::Result; - fn Name(&self) -> ::windows_core::Result; + fn GetCollection(&self, bstrcollname: &::windows_core::BSTR, varobjectkey: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Name(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn AddEnabled(&self) -> ::windows_core::Result; fn RemoveEnabled(&self) -> ::windows_core::Result; fn GetUtilInterface(&self) -> ::windows_core::Result; @@ -825,9 +825,9 @@ pub trait ICatalogCollection_Impl: Sized + super::Com::IDispatch_Impl { fn PopulateByKey(&self, psakeys: *const super::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn PopulateByQuery(&self, bstrquerystring: &::windows_core::BSTR, lquerytype: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICatalogCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICatalogCollection_Vtbl { pub const fn new, Impl: ICatalogCollection_Impl, const OFFSET: isize>() -> ICatalogCollection_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ICatalogCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenumvariant: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -895,7 +895,7 @@ impl ICatalogCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCollection, Impl: ICatalogCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varobjectkey: super::Variant::VARIANT, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCollection, Impl: ICatalogCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varobjectkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCollection(::core::mem::transmute(&bstrcollname), ::core::mem::transmute(&varobjectkey)) { @@ -906,7 +906,7 @@ impl ICatalogCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Name, Impl: ICatalogCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarnamel: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Name, Impl: ICatalogCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarnamel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Name() { @@ -1006,23 +1006,23 @@ impl ICatalogCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICatalogObject_Impl: Sized + super::Com::IDispatch_Impl { - fn get_Value(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result; - fn put_Value(&self, bstrpropname: &::windows_core::BSTR, val: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Key(&self) -> ::windows_core::Result; - fn Name(&self) -> ::windows_core::Result; + fn get_Value(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_Value(&self, bstrpropname: &::windows_core::BSTR, val: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Key(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Name(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsPropertyReadOnly(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result; fn Valid(&self) -> ::windows_core::Result; fn IsPropertyWriteOnly(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICatalogObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICatalogObject_Vtbl { pub const fn new, Impl: ICatalogObject_Impl, const OFFSET: isize>() -> ICatalogObject_Vtbl { - unsafe extern "system" fn get_Value, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Value, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Value(::core::mem::transmute(&bstrpropname)) { @@ -1033,12 +1033,12 @@ impl ICatalogObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Value, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, val: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Value, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Value(::core::mem::transmute(&bstrpropname), ::core::mem::transmute(&val)).into() } - unsafe extern "system" fn Key, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Key, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Key() { @@ -1049,7 +1049,7 @@ impl ICatalogObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Name, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Name, Impl: ICatalogObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Name() { @@ -2392,17 +2392,13 @@ impl IComTrackingInfoEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IComTrackingInfoObject_Impl: Sized { - fn GetValue(&self, szpropertyname: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetValue(&self, szpropertyname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IComTrackingInfoObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IComTrackingInfoObject_Vtbl { pub const fn new, Impl: IComTrackingInfoObject_Impl, const OFFSET: isize>() -> IComTrackingInfoObject_Vtbl { - unsafe extern "system" fn GetValue, Impl: IComTrackingInfoObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, szpropertyname: ::windows_core::PCWSTR, pvarout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IComTrackingInfoObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, szpropertyname: ::windows_core::PCWSTR, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute(&szpropertyname)) { @@ -2540,17 +2536,13 @@ impl IComTransactionEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IComUserEvent_Impl: Sized { - fn OnUserEvent(&self, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OnUserEvent(&self, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IComUserEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IComUserEvent_Vtbl { pub const fn new, Impl: IComUserEvent_Impl, const OFFSET: isize>() -> IComUserEvent_Vtbl { - unsafe extern "system" fn OnUserEvent, Impl: IComUserEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnUserEvent, Impl: IComUserEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnUserEvent(::core::mem::transmute_copy(&pinfo), ::core::mem::transmute_copy(&pvarevent)).into() @@ -2561,18 +2553,14 @@ impl IComUserEvent_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IContextProperties_Impl: Sized { fn Count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; - fn GetProperty(&self, name: &::windows_core::BSTR, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, name: &::windows_core::BSTR, pproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EnumNames(&self) -> ::windows_core::Result; - fn SetProperty(&self, name: &::windows_core::BSTR, property: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetProperty(&self, name: &::windows_core::BSTR, property: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RemoveProperty(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IContextProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IContextProperties_Vtbl { pub const fn new, Impl: IContextProperties_Impl, const OFFSET: isize>() -> IContextProperties_Vtbl { unsafe extern "system" fn Count, Impl: IContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -2580,7 +2568,7 @@ impl IContextProperties_Vtbl { let this = (*this).get_impl(); this.Count(::core::mem::transmute_copy(&plcount)).into() } - unsafe extern "system" fn GetProperty, Impl: IContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetProperty(::core::mem::transmute(&name), ::core::mem::transmute_copy(&pproperty)).into() @@ -2596,7 +2584,7 @@ impl IContextProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, property: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, property: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute(&name), ::core::mem::transmute(&property)).into() @@ -2853,23 +2841,19 @@ impl ICrmCompensator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ICrmCompensatorVariants_Impl: Sized { fn SetLogControlVariants(&self, plogcontrol: ::core::option::Option<&ICrmLogControl>) -> ::windows_core::Result<()>; fn BeginPrepareVariants(&self) -> ::windows_core::Result<()>; - fn PrepareRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn PrepareRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn EndPrepareVariants(&self) -> ::windows_core::Result; fn BeginCommitVariants(&self, brecovery: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn CommitRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn CommitRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn EndCommitVariants(&self) -> ::windows_core::Result<()>; fn BeginAbortVariants(&self, brecovery: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn AbortRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn AbortRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn EndAbortVariants(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ICrmCompensatorVariants {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ICrmCompensatorVariants_Vtbl { pub const fn new, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>() -> ICrmCompensatorVariants_Vtbl { unsafe extern "system" fn SetLogControlVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogcontrol: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2882,7 +2866,7 @@ impl ICrmCompensatorVariants_Vtbl { let this = (*this).get_impl(); this.BeginPrepareVariants().into() } - unsafe extern "system" fn PrepareRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn PrepareRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PrepareRecordVariants(::core::mem::transmute_copy(&plogrecord)) { @@ -2909,7 +2893,7 @@ impl ICrmCompensatorVariants_Vtbl { let this = (*this).get_impl(); this.BeginCommitVariants(::core::mem::transmute_copy(&brecovery)).into() } - unsafe extern "system" fn CommitRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn CommitRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CommitRecordVariants(::core::mem::transmute_copy(&plogrecord)) { @@ -2930,7 +2914,7 @@ impl ICrmCompensatorVariants_Vtbl { let this = (*this).get_impl(); this.BeginAbortVariants(::core::mem::transmute_copy(&brecovery)).into() } - unsafe extern "system" fn AbortRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn AbortRecordVariants, Impl: ICrmCompensatorVariants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AbortRecordVariants(::core::mem::transmute_copy(&plogrecord)) { @@ -2964,17 +2948,17 @@ impl ICrmCompensatorVariants_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICrmFormatLogRecords_Impl: Sized { fn GetColumnCount(&self) -> ::windows_core::Result; - fn GetColumnHeaders(&self) -> ::windows_core::Result; - fn GetColumn(&self, crmlogrec: &CrmLogRecordRead) -> ::windows_core::Result; - fn GetColumnVariants(&self, logrecord: &super::Variant::VARIANT) -> ::windows_core::Result; + fn GetColumnHeaders(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetColumn(&self, crmlogrec: &CrmLogRecordRead) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetColumnVariants(&self, logrecord: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICrmFormatLogRecords {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICrmFormatLogRecords_Vtbl { pub const fn new, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>() -> ICrmFormatLogRecords_Vtbl { unsafe extern "system" fn GetColumnCount, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcolumncount: *mut i32) -> ::windows_core::HRESULT { @@ -2988,7 +2972,7 @@ impl ICrmFormatLogRecords_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetColumnHeaders, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pheaders: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetColumnHeaders, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pheaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetColumnHeaders() { @@ -2999,7 +2983,7 @@ impl ICrmFormatLogRecords_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetColumn, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, crmlogrec: CrmLogRecordRead, pformattedlogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetColumn, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, crmlogrec: CrmLogRecordRead, pformattedlogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetColumn(::core::mem::transmute(&crmlogrec)) { @@ -3010,7 +2994,7 @@ impl ICrmFormatLogRecords_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetColumnVariants, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, logrecord: super::Variant::VARIANT, pformattedlogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetColumnVariants, Impl: ICrmFormatLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, logrecord: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pformattedlogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetColumnVariants(::core::mem::transmute(&logrecord)) { @@ -3033,20 +3017,20 @@ impl ICrmFormatLogRecords_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICrmLogControl_Impl: Sized { fn TransactionUOW(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RegisterCompensator(&self, lpcwstrprogidcompensator: &::windows_core::PCWSTR, lpcwstrdescription: &::windows_core::PCWSTR, lcrmregflags: i32) -> ::windows_core::Result<()>; - fn WriteLogRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn WriteLogRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ForceLog(&self) -> ::windows_core::Result<()>; fn ForgetLogRecord(&self) -> ::windows_core::Result<()>; fn ForceTransactionToAbort(&self) -> ::windows_core::Result<()>; fn WriteLogRecord(&self, rgblob: *const super::Com::BLOB, cblob: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICrmLogControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICrmLogControl_Vtbl { pub const fn new, Impl: ICrmLogControl_Impl, const OFFSET: isize>() -> ICrmLogControl_Vtbl { unsafe extern "system" fn TransactionUOW, Impl: ICrmLogControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3065,7 +3049,7 @@ impl ICrmLogControl_Vtbl { let this = (*this).get_impl(); this.RegisterCompensator(::core::mem::transmute(&lpcwstrprogidcompensator), ::core::mem::transmute(&lpcwstrdescription), ::core::mem::transmute_copy(&lcrmregflags)).into() } - unsafe extern "system" fn WriteLogRecordVariants, Impl: ICrmLogControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn WriteLogRecordVariants, Impl: ICrmLogControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WriteLogRecordVariants(::core::mem::transmute_copy(&plogrecord)).into() @@ -3105,15 +3089,15 @@ impl ICrmLogControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICrmMonitor_Impl: Sized { fn GetClerks(&self) -> ::windows_core::Result; - fn HoldClerk(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn HoldClerk(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICrmMonitor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICrmMonitor_Vtbl { pub const fn new, Impl: ICrmMonitor_Impl, const OFFSET: isize>() -> ICrmMonitor_Vtbl { unsafe extern "system" fn GetClerks, Impl: ICrmMonitor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pclerks: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3127,7 +3111,7 @@ impl ICrmMonitor_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn HoldClerk, Impl: ICrmMonitor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn HoldClerk, Impl: ICrmMonitor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.HoldClerk(::core::mem::transmute(&index)) { @@ -3148,23 +3132,23 @@ impl ICrmMonitor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICrmMonitorClerks_Impl: Sized + super::Com::IDispatch_Impl { - fn Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; - fn ProgIdCompensator(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; - fn Description(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; - fn TransactionUOW(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; - fn ActivityId(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn ProgIdCompensator(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Description(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn TransactionUOW(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ActivityId(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICrmMonitorClerks {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICrmMonitorClerks_Vtbl { pub const fn new, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>() -> ICrmMonitorClerks_Vtbl { - unsafe extern "system" fn Item, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&index)) { @@ -3197,7 +3181,7 @@ impl ICrmMonitorClerks_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ProgIdCompensator, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ProgIdCompensator, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ProgIdCompensator(::core::mem::transmute(&index)) { @@ -3208,7 +3192,7 @@ impl ICrmMonitorClerks_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Description, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Description, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Description(::core::mem::transmute(&index)) { @@ -3219,7 +3203,7 @@ impl ICrmMonitorClerks_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn TransactionUOW, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TransactionUOW, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TransactionUOW(::core::mem::transmute(&index)) { @@ -3230,7 +3214,7 @@ impl ICrmMonitorClerks_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ActivityId, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ActivityId, Impl: ICrmMonitorClerks_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ActivityId(::core::mem::transmute(&index)) { @@ -3256,18 +3240,18 @@ impl ICrmMonitorClerks_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICrmMonitorLogRecords_Impl: Sized { fn Count(&self) -> ::windows_core::Result; fn TransactionState(&self) -> ::windows_core::Result; fn StructuredRecords(&self) -> ::windows_core::Result; fn GetLogRecord(&self, dwindex: u32, pcrmlogrec: *mut CrmLogRecordRead) -> ::windows_core::Result<()>; - fn GetLogRecordVariants(&self, indexnumber: &super::Variant::VARIANT) -> ::windows_core::Result; + fn GetLogRecordVariants(&self, indexnumber: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICrmMonitorLogRecords {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICrmMonitorLogRecords_Vtbl { pub const fn new, Impl: ICrmMonitorLogRecords_Impl, const OFFSET: isize>() -> ICrmMonitorLogRecords_Vtbl { unsafe extern "system" fn Count, Impl: ICrmMonitorLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -3308,7 +3292,7 @@ impl ICrmMonitorLogRecords_Vtbl { let this = (*this).get_impl(); this.GetLogRecord(::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&pcrmlogrec)).into() } - unsafe extern "system" fn GetLogRecordVariants, Impl: ICrmMonitorLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexnumber: super::Variant::VARIANT, plogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetLogRecordVariants, Impl: ICrmMonitorLogRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexnumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>, plogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetLogRecordVariants(::core::mem::transmute(&indexnumber)) { @@ -3467,16 +3451,16 @@ impl IEnumNames_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEventServerTrace_Impl: Sized + super::Com::IDispatch_Impl { fn StartTraceGuid(&self, bstrguidevent: &::windows_core::BSTR, bstrguidfilter: &::windows_core::BSTR, lpidfilter: i32) -> ::windows_core::Result<()>; fn StopTraceGuid(&self, bstrguidevent: &::windows_core::BSTR, bstrguidfilter: &::windows_core::BSTR, lpidfilter: i32) -> ::windows_core::Result<()>; fn EnumTraceGuid(&self, plcntguids: *mut i32, pbstrguidlist: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEventServerTrace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEventServerTrace_Vtbl { pub const fn new, Impl: IEventServerTrace_Impl, const OFFSET: isize>() -> IEventServerTrace_Vtbl { unsafe extern "system" fn StartTraceGuid, Impl: IEventServerTrace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrguidevent: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrguidfilter: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpidfilter: i32) -> ::windows_core::HRESULT { @@ -3579,16 +3563,12 @@ impl IGetAppTrackerData_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IGetContextProperties_Impl: Sized { fn Count(&self, plcount: *mut i32) -> ::windows_core::Result<()>; - fn GetProperty(&self, name: &::windows_core::BSTR, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, name: &::windows_core::BSTR, pproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EnumNames(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IGetContextProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IGetContextProperties_Vtbl { pub const fn new, Impl: IGetContextProperties_Impl, const OFFSET: isize>() -> IGetContextProperties_Vtbl { unsafe extern "system" fn Count, Impl: IGetContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -3596,7 +3576,7 @@ impl IGetContextProperties_Vtbl { let this = (*this).get_impl(); this.Count(::core::mem::transmute_copy(&plcount)).into() } - unsafe extern "system" fn GetProperty, Impl: IGetContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IGetContextProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetProperty(::core::mem::transmute(&name), ::core::mem::transmute_copy(&pproperty)).into() @@ -3623,14 +3603,14 @@ impl IGetContextProperties_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGetSecurityCallContext_Impl: Sized + super::Com::IDispatch_Impl { fn GetSecurityCallContext(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGetSecurityCallContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGetSecurityCallContext_Vtbl { pub const fn new, Impl: IGetSecurityCallContext_Impl, const OFFSET: isize>() -> IGetSecurityCallContext_Vtbl { unsafe extern "system" fn GetSecurityCallContext, Impl: IGetSecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3719,16 +3699,12 @@ impl IHolder_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ILBEvents_Impl: Sized { fn TargetUp(&self, bstrservername: &::windows_core::BSTR, bstrclsideng: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TargetDown(&self, bstrservername: &::windows_core::BSTR, bstrclsideng: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn EngineDefined(&self, bstrpropname: &::windows_core::BSTR, varpropvalue: *const super::Variant::VARIANT, bstrclsideng: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn EngineDefined(&self, bstrpropname: &::windows_core::BSTR, varpropvalue: *const ::windows_core::VARIANT, bstrclsideng: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ILBEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ILBEvents_Vtbl { pub const fn new, Impl: ILBEvents_Impl, const OFFSET: isize>() -> ILBEvents_Vtbl { unsafe extern "system" fn TargetUp, Impl: ILBEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3741,7 +3717,7 @@ impl ILBEvents_Vtbl { let this = (*this).get_impl(); this.TargetDown(::core::mem::transmute(&bstrservername), ::core::mem::transmute(&bstrclsideng)).into() } - unsafe extern "system" fn EngineDefined, Impl: ILBEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varpropvalue: *const super::Variant::VARIANT, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn EngineDefined, Impl: ILBEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varpropvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EngineDefined(::core::mem::transmute(&bstrpropname), ::core::mem::transmute_copy(&varpropvalue), ::core::mem::transmute(&bstrclsideng)).into() @@ -3822,14 +3798,14 @@ impl IMTSCall_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMTSLocator_Impl: Sized + super::Com::IDispatch_Impl { fn GetEventDispatcher(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMTSLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMTSLocator_Vtbl { pub const fn new, Impl: IMTSLocator_Impl, const OFFSET: isize>() -> IMTSLocator_Vtbl { unsafe extern "system" fn GetEventDispatcher, Impl: IMTSLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3963,8 +3939,8 @@ impl IManagedPooledObj_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMessageMover_Impl: Sized + super::Com::IDispatch_Impl { fn SourcePath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSourcePath(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3974,9 +3950,9 @@ pub trait IMessageMover_Impl: Sized + super::Com::IDispatch_Impl { fn SetCommitBatchSize(&self, newval: i32) -> ::windows_core::Result<()>; fn MoveMessages(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMessageMover {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMessageMover_Vtbl { pub const fn new, Impl: IMessageMover_Impl, const OFFSET: isize>() -> IMessageMover_Vtbl { unsafe extern "system" fn SourcePath, Impl: IMessageMover_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4053,18 +4029,18 @@ impl IMessageMover_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMtsEventInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Names(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn EventID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Count(&self) -> ::windows_core::Result; - fn get_Value(&self, skey: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_Value(&self, skey: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMtsEventInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMtsEventInfo_Vtbl { pub const fn new, Impl: IMtsEventInfo_Impl, const OFFSET: isize>() -> IMtsEventInfo_Vtbl { unsafe extern "system" fn Names, Impl: IMtsEventInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4111,7 +4087,7 @@ impl IMtsEventInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Value, Impl: IMtsEventInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, skey: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Value, Impl: IMtsEventInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, skey: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Value(::core::mem::transmute(&skey)) { @@ -4135,18 +4111,18 @@ impl IMtsEventInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMtsEvents_Impl: Sized + super::Com::IDispatch_Impl { fn PackageName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn PackageGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn PostEvent(&self, vevent: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PostEvent(&self, vevent: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn FireEvents(&self) -> ::windows_core::Result; fn GetProcessID(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMtsEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMtsEvents_Vtbl { pub const fn new, Impl: IMtsEvents_Impl, const OFFSET: isize>() -> IMtsEvents_Vtbl { unsafe extern "system" fn PackageName, Impl: IMtsEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4171,7 +4147,7 @@ impl IMtsEvents_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PostEvent, Impl: IMtsEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vevent: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PostEvent, Impl: IMtsEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vevent: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PostEvent(::core::mem::transmute_copy(&vevent)).into() @@ -4211,16 +4187,16 @@ impl IMtsEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMtsGrp_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::IUnknown>; fn Refresh(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMtsGrp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMtsGrp_Vtbl { pub const fn new, Impl: IMtsGrp_Impl, const OFFSET: isize>() -> IMtsGrp_Vtbl { unsafe extern "system" fn Count, Impl: IMtsGrp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -4344,14 +4320,14 @@ impl IObjectConstruct_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IObjectConstructString_Impl: Sized + super::Com::IDispatch_Impl { fn ConstructString(&self, pval: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IObjectConstructString {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IObjectConstructString_Vtbl { pub const fn new, Impl: IObjectConstructString_Impl, const OFFSET: isize>() -> IObjectConstructString_Vtbl { unsafe extern "system" fn ConstructString, Impl: IObjectConstructString_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4617,14 +4593,14 @@ impl IPlaybackControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPoolManager_Impl: Sized + super::Com::IDispatch_Impl { fn ShutdownPool(&self, clsidorprogid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPoolManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPoolManager_Vtbl { pub const fn new, Impl: IPoolManager_Impl, const OFFSET: isize>() -> IPoolManager_Vtbl { unsafe extern "system" fn ShutdownPool, Impl: IPoolManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, clsidorprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4665,19 +4641,19 @@ impl IProcessInitializer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISecurityCallContext_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn IsCallerInRole(&self, bstrrole: &::windows_core::BSTR) -> ::windows_core::Result; fn IsSecurityEnabled(&self) -> ::windows_core::Result; - fn IsUserInRole(&self, puser: *const super::Variant::VARIANT, bstrrole: &::windows_core::BSTR) -> ::windows_core::Result; + fn IsUserInRole(&self, puser: *const ::windows_core::VARIANT, bstrrole: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISecurityCallContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISecurityCallContext_Vtbl { pub const fn new, Impl: ISecurityCallContext_Impl, const OFFSET: isize>() -> ISecurityCallContext_Vtbl { unsafe extern "system" fn Count, Impl: ISecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4691,7 +4667,7 @@ impl ISecurityCallContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&name)) { @@ -4735,7 +4711,7 @@ impl ISecurityCallContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn IsUserInRole, Impl: ISecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, puser: *const super::Variant::VARIANT, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsUserInRole, Impl: ISecurityCallContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, puser: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsUserInRole(::core::mem::transmute_copy(&puser), ::core::mem::transmute(&bstrrole)) { @@ -4760,16 +4736,16 @@ impl ISecurityCallContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISecurityCallersColl_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn get_Item(&self, lindex: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISecurityCallersColl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISecurityCallersColl_Vtbl { pub const fn new, Impl: ISecurityCallersColl_Impl, const OFFSET: isize>() -> ISecurityCallersColl_Vtbl { unsafe extern "system" fn Count, Impl: ISecurityCallersColl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4816,16 +4792,16 @@ impl ISecurityCallersColl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISecurityIdentityColl_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISecurityIdentityColl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISecurityIdentityColl_Vtbl { pub const fn new, Impl: ISecurityIdentityColl_Impl, const OFFSET: isize>() -> ISecurityIdentityColl_Vtbl { unsafe extern "system" fn Count, Impl: ISecurityIdentityColl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -4839,7 +4815,7 @@ impl ISecurityIdentityColl_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ISecurityIdentityColl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ISecurityIdentityColl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&name)) { @@ -5425,18 +5401,18 @@ impl IServiceTransactionConfigBase_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISharedProperty_Impl: Sized + super::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, val: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, val: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISharedProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISharedProperty_Vtbl { pub const fn new, Impl: ISharedProperty_Impl, const OFFSET: isize>() -> ISharedProperty_Vtbl { - unsafe extern "system" fn Value, Impl: ISharedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISharedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -5447,7 +5423,7 @@ impl ISharedProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISharedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, val: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISharedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&val)).into() @@ -5462,17 +5438,17 @@ impl ISharedProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISharedPropertyGroup_Impl: Sized + super::Com::IDispatch_Impl { fn CreatePropertyByPosition(&self, index: i32, fexists: *mut super::super::Foundation::VARIANT_BOOL, ppprop: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn get_PropertyByPosition(&self, index: i32) -> ::windows_core::Result; fn CreateProperty(&self, name: &::windows_core::BSTR, fexists: *mut super::super::Foundation::VARIANT_BOOL, ppprop: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn get_Property(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISharedPropertyGroup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISharedPropertyGroup_Vtbl { pub const fn new, Impl: ISharedPropertyGroup_Impl, const OFFSET: isize>() -> ISharedPropertyGroup_Vtbl { unsafe extern "system" fn CreatePropertyByPosition, Impl: ISharedPropertyGroup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, fexists: *mut super::super::Foundation::VARIANT_BOOL, ppprop: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5519,16 +5495,16 @@ impl ISharedPropertyGroup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISharedPropertyGroupManager_Impl: Sized + super::Com::IDispatch_Impl { fn CreatePropertyGroup(&self, name: &::windows_core::BSTR, dwisomode: *mut i32, dwrelmode: *mut i32, fexists: *mut super::super::Foundation::VARIANT_BOOL, ppgroup: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn get_Group(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISharedPropertyGroupManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISharedPropertyGroupManager_Vtbl { pub const fn new, Impl: ISharedPropertyGroupManager_Impl, const OFFSET: isize>() -> ISharedPropertyGroupManager_Vtbl { unsafe extern "system" fn CreatePropertyGroup, Impl: ISharedPropertyGroupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwisomode: *mut i32, dwrelmode: *mut i32, fexists: *mut super::super::Foundation::VARIANT_BOOL, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5679,19 +5655,19 @@ impl IThreadPoolKnobs_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITransactionContext_Impl: Sized + super::Com::IDispatch_Impl { - fn CreateInstance(&self, pszprogid: &::windows_core::BSTR) -> ::windows_core::Result; + fn CreateInstance(&self, pszprogid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn Commit(&self) -> ::windows_core::Result<()>; fn Abort(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITransactionContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITransactionContext_Vtbl { pub const fn new, Impl: ITransactionContext_Impl, const OFFSET: isize>() -> ITransactionContext_Vtbl { - unsafe extern "system" fn CreateInstance, Impl: ITransactionContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateInstance, Impl: ITransactionContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateInstance(::core::mem::transmute(&pszprogid)) { @@ -6057,10 +6033,10 @@ impl ITxProxyHolder_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ObjectContext_Impl: Sized + super::Com::IDispatch_Impl { - fn CreateInstance(&self, bstrprogid: &::windows_core::BSTR) -> ::windows_core::Result; + fn CreateInstance(&self, bstrprogid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetComplete(&self) -> ::windows_core::Result<()>; fn SetAbort(&self) -> ::windows_core::Result<()>; fn EnableCommit(&self) -> ::windows_core::Result<()>; @@ -6069,17 +6045,17 @@ pub trait ObjectContext_Impl: Sized + super::Com::IDispatch_Impl { fn IsSecurityEnabled(&self) -> ::windows_core::Result; fn IsCallerInRole(&self, bstrrole: &::windows_core::BSTR) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; + fn get_Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Security(&self) -> ::windows_core::Result; fn ContextInfo(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ObjectContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ObjectContext_Vtbl { pub const fn new, Impl: ObjectContext_Impl, const OFFSET: isize>() -> ObjectContext_Vtbl { - unsafe extern "system" fn CreateInstance, Impl: ObjectContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateInstance, Impl: ObjectContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateInstance(::core::mem::transmute(&bstrprogid)) { @@ -6154,7 +6130,7 @@ impl ObjectContext_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ObjectContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ObjectContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&name)) { @@ -6253,17 +6229,17 @@ impl ObjectControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait SecurityProperty_Impl: Sized + super::Com::IDispatch_Impl { fn GetDirectCallerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetDirectCreatorName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetOriginalCallerName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetOriginalCreatorName(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for SecurityProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl SecurityProperty_Vtbl { pub const fn new, Impl: SecurityProperty_Impl, const OFFSET: isize>() -> SecurityProperty_Vtbl { unsafe extern "system" fn GetDirectCallerName, Impl: SecurityProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrusername: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/ComponentServices/mod.rs b/crates/libs/windows/src/Windows/Win32/System/ComponentServices/mod.rs index 8da34f30da..d7f4fd9b3f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/ComponentServices/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/ComponentServices/mod.rs @@ -637,44 +637,34 @@ impl ICOMAdminCatalog2 { { (::windows_core::Interface::vtable(self).base__.GetEventClassesForIID)(::windows_core::Interface::as_raw(self), bstriid.into_param().abi(), ppsavarclsids, ppsavarprogids, ppsavardescriptions).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCollectionByQuery2(&self, bstrcollectionname: P0, pvarquerystrings: *const super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetCollectionByQuery2(&self, bstrcollectionname: P0, pvarquerystrings: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetCollectionByQuery2)(::windows_core::Interface::as_raw(self), bstrcollectionname.into_param().abi(), pvarquerystrings, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetCollectionByQuery2)(::windows_core::Interface::as_raw(self), bstrcollectionname.into_param().abi(), ::core::mem::transmute(pvarquerystrings), &mut result__).from_abi(result__) } pub unsafe fn GetApplicationInstanceIDFromProcessID(&self, lprocessid: i32) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetApplicationInstanceIDFromProcessID)(::windows_core::Interface::as_raw(self), lprocessid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShutdownApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ShutdownApplicationInstances)(::windows_core::Interface::as_raw(self), pvarapplicationinstanceid).ok() + pub unsafe fn ShutdownApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ShutdownApplicationInstances)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarapplicationinstanceid)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PauseApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PauseApplicationInstances)(::windows_core::Interface::as_raw(self), pvarapplicationinstanceid).ok() + pub unsafe fn PauseApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PauseApplicationInstances)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarapplicationinstanceid)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ResumeApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ResumeApplicationInstances)(::windows_core::Interface::as_raw(self), pvarapplicationinstanceid).ok() + pub unsafe fn ResumeApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ResumeApplicationInstances)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarapplicationinstanceid)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RecycleApplicationInstances(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT, lreasoncode: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RecycleApplicationInstances)(::windows_core::Interface::as_raw(self), pvarapplicationinstanceid, lreasoncode).ok() + pub unsafe fn RecycleApplicationInstances(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT, lreasoncode: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).RecycleApplicationInstances)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarapplicationinstanceid), lreasoncode).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AreApplicationInstancesPaused(&self, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn AreApplicationInstancesPaused(&self, pvarapplicationinstanceid: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).AreApplicationInstancesPaused)(::windows_core::Interface::as_raw(self), pvarapplicationinstanceid, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).AreApplicationInstancesPaused)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarapplicationinstanceid), &mut result__).from_abi(result__) } pub unsafe fn DumpApplicationInstance(&self, bstrapplicationinstanceid: P0, bstrdirectory: P1, lmaximages: i32) -> ::windows_core::Result<::windows_core::BSTR> where @@ -742,32 +732,26 @@ impl ICOMAdminCatalog2 { pub unsafe fn FlushPartitionCache(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).FlushPartitionCache)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyApplications(&self, bstrsourcepartitionidorname: P0, pvarapplicationid: *const super::Variant::VARIANT, bstrdestinationpartitionidorname: P1) -> ::windows_core::Result<()> + pub unsafe fn CopyApplications(&self, bstrsourcepartitionidorname: P0, pvarapplicationid: *const ::windows_core::VARIANT, bstrdestinationpartitionidorname: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).CopyApplications)(::windows_core::Interface::as_raw(self), bstrsourcepartitionidorname.into_param().abi(), pvarapplicationid, bstrdestinationpartitionidorname.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).CopyApplications)(::windows_core::Interface::as_raw(self), bstrsourcepartitionidorname.into_param().abi(), ::core::mem::transmute(pvarapplicationid), bstrdestinationpartitionidorname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyComponents(&self, bstrsourceapplicationidorname: P0, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: P1) -> ::windows_core::Result<()> + pub unsafe fn CopyComponents(&self, bstrsourceapplicationidorname: P0, pvarclsidorprogid: *const ::windows_core::VARIANT, bstrdestinationapplicationidorname: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).CopyComponents)(::windows_core::Interface::as_raw(self), bstrsourceapplicationidorname.into_param().abi(), pvarclsidorprogid, bstrdestinationapplicationidorname.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).CopyComponents)(::windows_core::Interface::as_raw(self), bstrsourceapplicationidorname.into_param().abi(), ::core::mem::transmute(pvarclsidorprogid), bstrdestinationapplicationidorname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveComponents(&self, bstrsourceapplicationidorname: P0, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: P1) -> ::windows_core::Result<()> + pub unsafe fn MoveComponents(&self, bstrsourceapplicationidorname: P0, pvarclsidorprogid: *const ::windows_core::VARIANT, bstrdestinationapplicationidorname: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).MoveComponents)(::windows_core::Interface::as_raw(self), bstrsourceapplicationidorname.into_param().abi(), pvarclsidorprogid, bstrdestinationapplicationidorname.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).MoveComponents)(::windows_core::Interface::as_raw(self), bstrsourceapplicationidorname.into_param().abi(), ::core::mem::transmute(pvarclsidorprogid), bstrdestinationapplicationidorname.into_param().abi()).ok() } pub unsafe fn AliasComponent(&self, bstrsrcapplicationidorname: P0, bstrclsidorprogid: P1, bstrdestapplicationidorname: P2, bstrnewprogid: P3, bstrnewclsid: P4) -> ::windows_core::Result<()> where @@ -786,29 +770,23 @@ impl ICOMAdminCatalog2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsSafeToDelete)(::windows_core::Interface::as_raw(self), bstrdllname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportUnconfiguredComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ImportUnconfiguredComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ImportUnconfiguredComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), pvarclsidorprogid, pvarcomponenttype).ok() + (::windows_core::Interface::vtable(self).ImportUnconfiguredComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), ::core::mem::transmute(pvarclsidorprogid), ::core::mem::transmute(pvarcomponenttype)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PromoteUnconfiguredComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PromoteUnconfiguredComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).PromoteUnconfiguredComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), pvarclsidorprogid, pvarcomponenttype).ok() + (::windows_core::Interface::vtable(self).PromoteUnconfiguredComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), ::core::mem::transmute(pvarclsidorprogid), ::core::mem::transmute(pvarcomponenttype)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ImportComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ImportComponents(&self, bstrapplicationidorname: P0, pvarclsidorprogid: *const ::windows_core::VARIANT, pvarcomponenttype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).ImportComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), pvarclsidorprogid, pvarcomponenttype).ok() + (::windows_core::Interface::vtable(self).ImportComponents)(::windows_core::Interface::as_raw(self), bstrapplicationidorname.into_param().abi(), ::core::mem::transmute(pvarclsidorprogid), ::core::mem::transmute(pvarcomponenttype)).ok() } pub unsafe fn Is64BitCatalogServer(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -853,31 +831,16 @@ impl ICOMAdminCatalog2 { #[doc(hidden)] pub struct ICOMAdminCatalog2_Vtbl { pub base__: ICOMAdminCatalog_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCollectionByQuery2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcollectionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarquerystrings: *const super::Variant::VARIANT, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GetCollectionByQuery2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcollectionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarquerystrings: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetCollectionByQuery2: usize, pub GetApplicationInstanceIDFromProcessID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lprocessid: i32, pbstrapplicationinstanceid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ShutdownApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ShutdownApplicationInstances: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PauseApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PauseApplicationInstances: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ResumeApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ResumeApplicationInstances: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RecycleApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT, lreasoncode: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RecycleApplicationInstances: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AreApplicationInstancesPaused: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const super::Variant::VARIANT, pvarboolpaused: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AreApplicationInstancesPaused: usize, + pub ShutdownApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PauseApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ResumeApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub RecycleApplicationInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lreasoncode: i32) -> ::windows_core::HRESULT, + pub AreApplicationInstancesPaused: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarapplicationinstanceid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarboolpaused: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub DumpApplicationInstance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationinstanceid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdirectory: ::std::mem::MaybeUninit<::windows_core::BSTR>, lmaximages: i32, pbstrdumpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsApplicationInstanceDumpSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbooldumpsupported: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub CreateServiceForApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrservicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrstarttype: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrerrorcontrol: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdependencies: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrrunas: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, bdesktopok: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -889,32 +852,14 @@ pub struct ICOMAdminCatalog2_Vtbl { pub CurrentPartitionName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrpartitionname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GlobalPartitionID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrglobalpartitionid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub FlushPartitionCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyApplications: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourcepartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarapplicationid: *const super::Variant::VARIANT, bstrdestinationpartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CopyApplications: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CopyComponents: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveComponents: usize, + pub CopyApplications: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourcepartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarapplicationid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationpartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub CopyComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub MoveComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsourceapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrdestinationapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub AliasComponent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsrcapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrclsidorprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdestapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnewprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnewclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsSafeToDelete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrdllname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcomadmininuse: *mut COMAdminInUse) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportUnconfiguredComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ImportUnconfiguredComponents: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PromoteUnconfiguredComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PromoteUnconfiguredComponents: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ImportComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const super::Variant::VARIANT, pvarcomponenttype: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ImportComponents: usize, + pub ImportUnconfiguredComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PromoteUnconfiguredComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ImportComponents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrapplicationidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarclsidorprogid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarcomponenttype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Is64BitCatalogServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbis64bit: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub ExportPartition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpartitionidorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpartitionfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: COMAdminApplicationExportOptions) -> ::windows_core::HRESULT, pub InstallPartition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrfilename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdestdirectory: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: COMAdminApplicationInstallOptions, bstruserid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrrsn: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -990,18 +935,17 @@ impl ICatalogCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SaveChanges)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCollection(&self, bstrcollname: P0, varobjectkey: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetCollection(&self, bstrcollname: P0, varobjectkey: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetCollection)(::windows_core::Interface::as_raw(self), bstrcollname.into_param().abi(), ::core::mem::transmute(varobjectkey), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetCollection)(::windows_core::Interface::as_raw(self), bstrcollname.into_param().abi(), varobjectkey.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Name(&self) -> ::windows_core::Result { + pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1057,14 +1001,11 @@ pub struct ICatalogCollection_Vtbl { Add: usize, pub Populate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SaveChanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcchanges: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varobjectkey: super::Variant::VARIANT, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GetCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varobjectkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetCollection: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarnamel: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Name: usize, + pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarnamel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AddEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub RemoveEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -1090,32 +1031,25 @@ pub struct ICatalogCollection_Vtbl { ::windows_core::imp::interface_hierarchy!(ICatalogObject, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ICatalogObject { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Value(&self, bstrpropname: P0) -> ::windows_core::Result + pub unsafe fn get_Value(&self, bstrpropname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Value)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Value(&self, bstrpropname: P0, val: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn put_Value(&self, bstrpropname: P0, val: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).put_Value)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), ::core::mem::transmute(val)).ok() + (::windows_core::Interface::vtable(self).put_Value)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), val.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Key(&self) -> ::windows_core::Result { + pub unsafe fn Key(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Key)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Name(&self) -> ::windows_core::Result { + pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1143,22 +1077,10 @@ impl ICatalogObject { #[doc(hidden)] pub struct ICatalogObject_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, val: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Key: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Key: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarretval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Name: usize, + pub get_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Key: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsPropertyReadOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbretval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Valid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbretval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsPropertyWriteOnly: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbretval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -2022,9 +1944,7 @@ pub struct IComTrackingInfoEvents_Vtbl { ::windows_core::imp::com_interface!(IComTrackingInfoObject, IComTrackingInfoObject_Vtbl, 0x116e42c5_d8b1_47bf_ab1e_c895ed3e2372); ::windows_core::imp::interface_hierarchy!(IComTrackingInfoObject, ::windows_core::IUnknown); impl IComTrackingInfoObject { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, szpropertyname: P0) -> ::windows_core::Result + pub unsafe fn GetValue(&self, szpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -2036,10 +1956,7 @@ impl IComTrackingInfoObject { #[doc(hidden)] pub struct IComTrackingInfoObject_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, szpropertyname: ::windows_core::PCWSTR, pvarout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, szpropertyname: ::windows_core::PCWSTR, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IComTrackingInfoProperties, IComTrackingInfoProperties_Vtbl, 0x789b42be_6f6b_443a_898e_67abf390aa14); ::windows_core::imp::interface_hierarchy!(IComTrackingInfoProperties, ::windows_core::IUnknown); @@ -2125,20 +2042,15 @@ pub struct IComTransactionEvents_Vtbl { ::windows_core::imp::com_interface!(IComUserEvent, IComUserEvent_Vtbl, 0x683130a4_2e50_11d2_98a5_00c04f8ee1c4); ::windows_core::imp::interface_hierarchy!(IComUserEvent, ::windows_core::IUnknown); impl IComUserEvent { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnUserEvent(&self, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnUserEvent)(::windows_core::Interface::as_raw(self), pinfo, pvarevent).ok() + pub unsafe fn OnUserEvent(&self, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnUserEvent)(::windows_core::Interface::as_raw(self), pinfo, ::core::mem::transmute(pvarevent)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IComUserEvent_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnUserEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnUserEvent: usize, + pub OnUserEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinfo: *const COMSVCSEVENTINFO, pvarevent: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IContextProperties, IContextProperties_Vtbl, 0xd396da85_bf8f_11d1_bbae_00c04fc2fa5f); ::windows_core::imp::interface_hierarchy!(IContextProperties, ::windows_core::IUnknown); @@ -2146,25 +2058,22 @@ impl IContextProperties { pub unsafe fn Count(&self, plcount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), plcount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, name: P0, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetProperty(&self, name: P0, pproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } pub unsafe fn EnumNames(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnumNames)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, name: P0, property: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetProperty(&self, name: P0, property: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(property)).ok() + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), property.into_param().abi()).ok() } pub unsafe fn RemoveProperty(&self, name: P0) -> ::windows_core::Result<()> where @@ -2178,15 +2087,9 @@ impl IContextProperties { pub struct IContextProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, property: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, property: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RemoveProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IContextSecurityPerimeter, IContextSecurityPerimeter_Vtbl, 0xa7549a29_a7c4_42e1_8dc1_7e3d748dc24a); @@ -2383,11 +2286,9 @@ impl ICrmCompensatorVariants { pub unsafe fn BeginPrepareVariants(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BeginPrepareVariants)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrepareRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn PrepareRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PrepareRecordVariants)(::windows_core::Interface::as_raw(self), plogrecord, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PrepareRecordVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(plogrecord), &mut result__).from_abi(result__) } pub unsafe fn EndPrepareVariants(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2399,11 +2300,9 @@ impl ICrmCompensatorVariants { { (::windows_core::Interface::vtable(self).BeginCommitVariants)(::windows_core::Interface::as_raw(self), brecovery.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CommitRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CommitRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CommitRecordVariants)(::windows_core::Interface::as_raw(self), plogrecord, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CommitRecordVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(plogrecord), &mut result__).from_abi(result__) } pub unsafe fn EndCommitVariants(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndCommitVariants)(::windows_core::Interface::as_raw(self)).ok() @@ -2414,11 +2313,9 @@ impl ICrmCompensatorVariants { { (::windows_core::Interface::vtable(self).BeginAbortVariants)(::windows_core::Interface::as_raw(self), brecovery.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AbortRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn AbortRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).AbortRecordVariants)(::windows_core::Interface::as_raw(self), plogrecord, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).AbortRecordVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(plogrecord), &mut result__).from_abi(result__) } pub unsafe fn EndAbortVariants(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndAbortVariants)(::windows_core::Interface::as_raw(self)).ok() @@ -2430,22 +2327,13 @@ pub struct ICrmCompensatorVariants_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub SetLogControlVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogcontrol: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub BeginPrepareVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PrepareRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PrepareRecordVariants: usize, + pub PrepareRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub EndPrepareVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pboktoprepare: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub BeginCommitVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, brecovery: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CommitRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CommitRecordVariants: usize, + pub CommitRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub EndCommitVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub BeginAbortVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, brecovery: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AbortRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AbortRecordVariants: usize, + pub AbortRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbforget: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub EndAbortVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ICrmFormatLogRecords, ICrmFormatLogRecords_Vtbl, 0x9c51d821_c98b_11d1_82fb_00a0c91eede9); @@ -2455,23 +2343,22 @@ impl ICrmFormatLogRecords { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetColumnCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetColumnHeaders(&self) -> ::windows_core::Result { + pub unsafe fn GetColumnHeaders(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetColumnHeaders)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetColumn(&self, crmlogrec: CrmLogRecordRead) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetColumn(&self, crmlogrec: CrmLogRecordRead) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetColumn)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(crmlogrec), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetColumnVariants(&self, logrecord: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetColumnVariants(&self, logrecord: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetColumnVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(logrecord), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetColumnVariants)(::windows_core::Interface::as_raw(self), logrecord.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] @@ -2479,18 +2366,12 @@ impl ICrmFormatLogRecords { pub struct ICrmFormatLogRecords_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetColumnCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcolumncount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetColumnHeaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pheaders: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetColumnHeaders: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, crmlogrec: CrmLogRecordRead, pformattedlogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub GetColumnHeaders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pheaders: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub GetColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, crmlogrec: CrmLogRecordRead, pformattedlogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetColumn: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetColumnVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, logrecord: super::Variant::VARIANT, pformattedlogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetColumnVariants: usize, + pub GetColumnVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, logrecord: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pformattedlogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ICrmLogControl, ICrmLogControl_Vtbl, 0xa0e174b3_d26e_11d2_8f84_00805fc7bcd9); ::windows_core::imp::interface_hierarchy!(ICrmLogControl, ::windows_core::IUnknown); @@ -2506,10 +2387,8 @@ impl ICrmLogControl { { (::windows_core::Interface::vtable(self).RegisterCompensator)(::windows_core::Interface::as_raw(self), lpcwstrprogidcompensator.into_param().abi(), lpcwstrdescription.into_param().abi(), lcrmregflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn WriteLogRecordVariants(&self, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).WriteLogRecordVariants)(::windows_core::Interface::as_raw(self), plogrecord).ok() + pub unsafe fn WriteLogRecordVariants(&self, plogrecord: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).WriteLogRecordVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(plogrecord)).ok() } pub unsafe fn ForceLog(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ForceLog)(::windows_core::Interface::as_raw(self)).ok() @@ -2532,10 +2411,7 @@ pub struct ICrmLogControl_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub TransactionUOW: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RegisterCompensator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lpcwstrprogidcompensator: ::windows_core::PCWSTR, lpcwstrdescription: ::windows_core::PCWSTR, lcrmregflags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub WriteLogRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - WriteLogRecordVariants: usize, + pub WriteLogRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plogrecord: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ForceLog: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ForgetLogRecord: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ForceTransactionToAbort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2553,11 +2429,12 @@ impl ICrmMonitor { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetClerks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn HoldClerk(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn HoldClerk(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).HoldClerk)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).HoldClerk)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] @@ -2568,10 +2445,7 @@ pub struct ICrmMonitor_Vtbl { pub GetClerks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pclerks: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetClerks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub HoldClerk: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - HoldClerk: usize, + pub HoldClerk: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2584,11 +2458,12 @@ pub struct ICrmMonitor_Vtbl { ::windows_core::imp::interface_hierarchy!(ICrmMonitorClerks, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ICrmMonitorClerks { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -2598,29 +2473,33 @@ impl ICrmMonitorClerks { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ProgIdCompensator(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn ProgIdCompensator(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ProgIdCompensator)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ProgIdCompensator)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Description(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Description(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Description)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Description)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TransactionUOW(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn TransactionUOW(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).TransactionUOW)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).TransactionUOW)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ActivityId(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn ActivityId(&self, index: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ActivityId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ActivityId)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -2628,28 +2507,13 @@ impl ICrmMonitorClerks { #[doc(hidden)] pub struct ICrmMonitorClerks_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Item: usize, + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ProgIdCompensator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ProgIdCompensator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Description: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TransactionUOW: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TransactionUOW: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ActivityId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ActivityId: usize, + pub ProgIdCompensator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub TransactionUOW: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ActivityId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ICrmMonitorLogRecords, ICrmMonitorLogRecords_Vtbl, 0x70c8e441_c7ed_11d1_82fb_00a0c91eede9); ::windows_core::imp::interface_hierarchy!(ICrmMonitorLogRecords, ::windows_core::IUnknown); @@ -2671,11 +2535,12 @@ impl ICrmMonitorLogRecords { pub unsafe fn GetLogRecord(&self, dwindex: u32, pcrmlogrec: *mut CrmLogRecordRead) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetLogRecord)(::windows_core::Interface::as_raw(self), dwindex, pcrmlogrec).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetLogRecordVariants(&self, indexnumber: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetLogRecordVariants(&self, indexnumber: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetLogRecordVariants)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(indexnumber), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetLogRecordVariants)(::windows_core::Interface::as_raw(self), indexnumber.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] @@ -2689,10 +2554,7 @@ pub struct ICrmMonitorLogRecords_Vtbl { pub GetLogRecord: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pcrmlogrec: *mut CrmLogRecordRead) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetLogRecord: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetLogRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexnumber: super::Variant::VARIANT, plogrecord: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetLogRecordVariants: usize, + pub GetLogRecordVariants: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexnumber: ::std::mem::MaybeUninit<::windows_core::VARIANT>, plogrecord: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDispenserDriver, IDispenserDriver_Vtbl, 0x208b3651_2b48_11cf_be10_00aa00a2fa25); ::windows_core::imp::interface_hierarchy!(IDispenserDriver, ::windows_core::IUnknown); @@ -2861,13 +2723,11 @@ impl IGetContextProperties { pub unsafe fn Count(&self, plcount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), plcount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, name: P0, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetProperty(&self, name: P0, pproperty: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } pub unsafe fn EnumNames(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2879,10 +2739,7 @@ impl IGetContextProperties { pub struct IGetContextProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -2977,14 +2834,12 @@ impl ILBEvents { { (::windows_core::Interface::vtable(self).TargetDown)(::windows_core::Interface::as_raw(self), bstrservername.into_param().abi(), bstrclsideng.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EngineDefined(&self, bstrpropname: P0, varpropvalue: *const super::Variant::VARIANT, bstrclsideng: P1) -> ::windows_core::Result<()> + pub unsafe fn EngineDefined(&self, bstrpropname: P0, varpropvalue: *const ::windows_core::VARIANT, bstrclsideng: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).EngineDefined)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), varpropvalue, bstrclsideng.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).EngineDefined)(::windows_core::Interface::as_raw(self), bstrpropname.into_param().abi(), ::core::mem::transmute(varpropvalue), bstrclsideng.into_param().abi()).ok() } } #[repr(C)] @@ -2993,10 +2848,7 @@ pub struct ILBEvents_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub TargetUp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub TargetDown: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EngineDefined: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varpropvalue: *const super::Variant::VARIANT, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EngineDefined: usize, + pub EngineDefined: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varpropvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrclsideng: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IMTSActivity, IMTSActivity_Vtbl, 0x51372af0_cae7_11cf_be81_00aa00a2fa25); ::windows_core::imp::interface_hierarchy!(IMTSActivity, ::windows_core::IUnknown); @@ -3239,9 +3091,7 @@ impl IMtsEventInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Value(&self, skey: P0) -> ::windows_core::Result + pub unsafe fn get_Value(&self, skey: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3258,10 +3108,7 @@ pub struct IMtsEventInfo_Vtbl { pub DisplayName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sdisplayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub EventID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sguideventid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, skey: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Value: usize, + pub get_Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, skey: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3282,10 +3129,8 @@ impl IMtsEvents { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PackageGuid)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PostEvent(&self, vevent: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PostEvent)(::windows_core::Interface::as_raw(self), vevent).ok() + pub unsafe fn PostEvent(&self, vevent: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PostEvent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vevent)).ok() } pub unsafe fn FireEvents(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3303,10 +3148,7 @@ pub struct IMtsEvents_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub PackageName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PackageGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PostEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vevent: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PostEvent: usize, + pub PostEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vevent: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub FireEvents: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub GetProcessID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT, } @@ -3660,9 +3502,7 @@ impl ISecurityCallContext { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result + pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3684,14 +3524,12 @@ impl ISecurityCallContext { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsSecurityEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsUserInRole(&self, puser: *const super::Variant::VARIANT, bstrrole: P0) -> ::windows_core::Result + pub unsafe fn IsUserInRole(&self, puser: *const ::windows_core::VARIANT, bstrrole: P0) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).IsUserInRole)(::windows_core::Interface::as_raw(self), puser, bstrrole.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).IsUserInRole)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(puser), bstrrole.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3700,17 +3538,11 @@ impl ISecurityCallContext { pub struct ISecurityCallContext_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub IsCallerInRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsSecurityEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfisenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsUserInRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, puser: *const super::Variant::VARIANT, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsUserInRole: usize, + pub IsUserInRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, puser: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pfinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3765,9 +3597,7 @@ impl ISecurityIdentityColl { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result + pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3785,10 +3615,7 @@ impl ISecurityIdentityColl { pub struct ISecurityIdentityColl_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ISecurityProperty, ISecurityProperty_Vtbl, 0x51372aea_cae7_11cf_be81_00aa00a2fa25); @@ -4257,16 +4084,15 @@ pub struct IServiceTransactionConfigBase_Vtbl { ::windows_core::imp::interface_hierarchy!(ISharedProperty, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISharedProperty { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, val: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(val)).ok() + pub unsafe fn SetValue(&self, val: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), val.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4274,14 +4100,8 @@ impl ISharedProperty { #[doc(hidden)] pub struct ISharedProperty_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, val: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4473,9 +4293,7 @@ pub struct IThreadPoolKnobs_Vtbl { ::windows_core::imp::interface_hierarchy!(ITransactionContext, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ITransactionContext { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateInstance(&self, pszprogid: P0) -> ::windows_core::Result + pub unsafe fn CreateInstance(&self, pszprogid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4494,10 +4312,7 @@ impl ITransactionContext { #[doc(hidden)] pub struct ITransactionContext_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateInstance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateInstance: usize, + pub CreateInstance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -4726,9 +4541,7 @@ pub struct ITxProxyHolder_Vtbl { ::windows_core::imp::interface_hierarchy!(ObjectContext, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ObjectContext { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateInstance(&self, bstrprogid: P0) -> ::windows_core::Result + pub unsafe fn CreateInstance(&self, bstrprogid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4766,9 +4579,7 @@ impl ObjectContext { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result + pub unsafe fn get_Item(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -4797,10 +4608,7 @@ impl ObjectContext { #[doc(hidden)] pub struct ObjectContext_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateInstance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateInstance: usize, + pub CreateInstance: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprogid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pobject: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetComplete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetAbort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EnableCommit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4809,10 +4617,7 @@ pub struct ObjectContext_Vtbl { pub IsSecurityEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbisenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsCallerInRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrrole: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbinrole: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pitem: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsecurityproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/DeploymentServices/impl.rs b/crates/libs/windows/src/Windows/Win32/System/DeploymentServices/impl.rs index 0049423d3a..7baa1bd0ca 100644 --- a/crates/libs/windows/src/Windows/Win32/System/DeploymentServices/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/DeploymentServices/impl.rs @@ -1,14 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportCacheable_Impl: Sized + super::Com::IDispatch_Impl { fn Dirty(&self) -> ::windows_core::Result; fn Discard(&self) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; fn Commit(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportCacheable {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportCacheable_Vtbl { pub const fn new, Impl: IWdsTransportCacheable_Impl, const OFFSET: isize>() -> IWdsTransportCacheable_Vtbl { unsafe extern "system" fn Dirty, Impl: IWdsTransportCacheable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbdirty: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -49,8 +49,8 @@ impl IWdsTransportCacheable_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportClient_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; @@ -65,9 +65,9 @@ pub trait IWdsTransportClient_Impl: Sized + super::Com::IDispatch_Impl { fn UserIdentity(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Disconnect(&self, disconnectiontype: WDSTRANSPORT_DISCONNECT_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportClient {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportClient_Vtbl { pub const fn new, Impl: IWdsTransportClient_Impl, const OFFSET: isize>() -> IWdsTransportClient_Vtbl { unsafe extern "system" fn Session, Impl: IWdsTransportClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransportsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -216,16 +216,16 @@ impl IWdsTransportClient_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn get_Item(&self, ulindex: u32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportCollection_Vtbl { pub const fn new, Impl: IWdsTransportCollection_Impl, const OFFSET: isize>() -> IWdsTransportCollection_Vtbl { unsafe extern "system" fn Count, Impl: IWdsTransportCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulcount: *mut u32) -> ::windows_core::HRESULT { @@ -272,8 +272,8 @@ impl IWdsTransportCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportConfigurationManager_Impl: Sized + super::Com::IDispatch_Impl { fn ServicePolicy(&self) -> ::windows_core::Result; fn DiagnosticsPolicy(&self) -> ::windows_core::Result; @@ -285,9 +285,9 @@ pub trait IWdsTransportConfigurationManager_Impl: Sized + super::Com::IDispatch_ fn RestartWdsTransportServices(&self) -> ::windows_core::Result<()>; fn NotifyWdsTransportServices(&self, servicenotification: WDSTRANSPORT_SERVICE_NOTIFICATION) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportConfigurationManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportConfigurationManager_Vtbl { pub const fn new, Impl: IWdsTransportConfigurationManager_Impl, const OFFSET: isize>() -> IWdsTransportConfigurationManager_Vtbl { unsafe extern "system" fn ServicePolicy, Impl: IWdsTransportConfigurationManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransportservicepolicy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -370,14 +370,14 @@ impl IWdsTransportConfigurationManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportConfigurationManager2_Impl: Sized + IWdsTransportConfigurationManager_Impl { fn MulticastSessionPolicy(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportConfigurationManager2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportConfigurationManager2_Vtbl { pub const fn new, Impl: IWdsTransportConfigurationManager2_Impl, const OFFSET: isize>() -> IWdsTransportConfigurationManager2_Vtbl { unsafe extern "system" fn MulticastSessionPolicy, Impl: IWdsTransportConfigurationManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransportmulticastsessionpolicy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -400,8 +400,8 @@ impl IWdsTransportConfigurationManager2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportContent_Impl: Sized + super::Com::IDispatch_Impl { fn Namespace(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; @@ -409,9 +409,9 @@ pub trait IWdsTransportContent_Impl: Sized + super::Com::IDispatch_Impl { fn RetrieveSessions(&self) -> ::windows_core::Result; fn Terminate(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportContent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportContent_Vtbl { pub const fn new, Impl: IWdsTransportContent_Impl, const OFFSET: isize>() -> IWdsTransportContent_Vtbl { unsafe extern "system" fn Namespace, Impl: IWdsTransportContent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransportnamespace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -476,17 +476,17 @@ impl IWdsTransportContent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportContentProvider_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn FilePath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitializationRoutine(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportContentProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportContentProvider_Vtbl { pub const fn new, Impl: IWdsTransportContentProvider_Impl, const OFFSET: isize>() -> IWdsTransportContentProvider_Vtbl { unsafe extern "system" fn Name, Impl: IWdsTransportContentProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -545,17 +545,17 @@ impl IWdsTransportContentProvider_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportDiagnosticsPolicy_Impl: Sized + IWdsTransportCacheable_Impl { fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, benabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Components(&self) -> ::windows_core::Result; fn SetComponents(&self, ulcomponents: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportDiagnosticsPolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportDiagnosticsPolicy_Vtbl { pub const fn new, Impl: IWdsTransportDiagnosticsPolicy_Impl, const OFFSET: isize>() -> IWdsTransportDiagnosticsPolicy_Vtbl { unsafe extern "system" fn Enabled, Impl: IWdsTransportDiagnosticsPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -602,14 +602,14 @@ impl IWdsTransportDiagnosticsPolicy_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportManager_Impl: Sized + super::Com::IDispatch_Impl { fn GetWdsTransportServer(&self, bszservername: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportManager_Vtbl { pub const fn new, Impl: IWdsTransportManager_Impl, const OFFSET: isize>() -> IWdsTransportManager_Vtbl { unsafe extern "system" fn GetWdsTransportServer, Impl: IWdsTransportManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bszservername: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppwdstransportserver: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -629,8 +629,8 @@ impl IWdsTransportManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportMulticastSessionPolicy_Impl: Sized + IWdsTransportCacheable_Impl { fn SlowClientHandling(&self) -> ::windows_core::Result; fn SetSlowClientHandling(&self, slowclienthandling: WDSTRANSPORT_SLOW_CLIENT_HANDLING_TYPE) -> ::windows_core::Result<()>; @@ -641,9 +641,9 @@ pub trait IWdsTransportMulticastSessionPolicy_Impl: Sized + IWdsTransportCacheab fn SlowClientFallback(&self) -> ::windows_core::Result; fn SetSlowClientFallback(&self, bclientfallback: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportMulticastSessionPolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportMulticastSessionPolicy_Vtbl { pub const fn new, Impl: IWdsTransportMulticastSessionPolicy_Impl, const OFFSET: isize>() -> IWdsTransportMulticastSessionPolicy_Vtbl { unsafe extern "system" fn SlowClientHandling, Impl: IWdsTransportMulticastSessionPolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pslowclienthandling: *mut WDSTRANSPORT_SLOW_CLIENT_HANDLING_TYPE) -> ::windows_core::HRESULT { @@ -726,8 +726,8 @@ impl IWdsTransportMulticastSessionPolicy_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespace_Impl: Sized + super::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; @@ -751,9 +751,9 @@ pub trait IWdsTransportNamespace_Impl: Sized + super::Com::IDispatch_Impl { fn Refresh(&self) -> ::windows_core::Result<()>; fn RetrieveContents(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespace_Vtbl { pub const fn new, Impl: IWdsTransportNamespace_Impl, const OFFSET: isize>() -> IWdsTransportNamespace_Vtbl { unsafe extern "system" fn Type, Impl: IWdsTransportNamespace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptype: *mut WDSTRANSPORT_NAMESPACE_TYPE) -> ::windows_core::HRESULT { @@ -968,12 +968,12 @@ impl IWdsTransportNamespace_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespaceAutoCast_Impl: Sized + IWdsTransportNamespace_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespaceAutoCast {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespaceAutoCast_Vtbl { pub const fn new, Impl: IWdsTransportNamespaceAutoCast_Impl, const OFFSET: isize>() -> IWdsTransportNamespaceAutoCast_Vtbl { Self { base__: IWdsTransportNamespace_Vtbl::new::() } @@ -982,16 +982,16 @@ impl IWdsTransportNamespaceAutoCast_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespaceManager_Impl: Sized + super::Com::IDispatch_Impl { fn CreateNamespace(&self, namespacetype: WDSTRANSPORT_NAMESPACE_TYPE, bsznamespacename: &::windows_core::BSTR, bszcontentprovider: &::windows_core::BSTR, bszconfiguration: &::windows_core::BSTR) -> ::windows_core::Result; fn RetrieveNamespace(&self, bsznamespacename: &::windows_core::BSTR) -> ::windows_core::Result; fn RetrieveNamespaces(&self, bszcontentprovider: &::windows_core::BSTR, bsznamespacename: &::windows_core::BSTR, bincludetombstones: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespaceManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespaceManager_Vtbl { pub const fn new, Impl: IWdsTransportNamespaceManager_Impl, const OFFSET: isize>() -> IWdsTransportNamespaceManager_Vtbl { unsafe extern "system" fn CreateNamespace, Impl: IWdsTransportNamespaceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, namespacetype: WDSTRANSPORT_NAMESPACE_TYPE, bsznamespacename: ::std::mem::MaybeUninit<::windows_core::BSTR>, bszcontentprovider: ::std::mem::MaybeUninit<::windows_core::BSTR>, bszconfiguration: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppwdstransportnamespace: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1038,14 +1038,14 @@ impl IWdsTransportNamespaceManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespaceScheduledCast_Impl: Sized + IWdsTransportNamespace_Impl { fn StartTransmission(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespaceScheduledCast {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespaceScheduledCast_Vtbl { pub const fn new, Impl: IWdsTransportNamespaceScheduledCast_Impl, const OFFSET: isize>() -> IWdsTransportNamespaceScheduledCast_Vtbl { unsafe extern "system" fn StartTransmission, Impl: IWdsTransportNamespaceScheduledCast_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1059,17 +1059,17 @@ impl IWdsTransportNamespaceScheduledCast_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespaceScheduledCastAutoStart_Impl: Sized + IWdsTransportNamespaceScheduledCast_Impl { fn MinimumClients(&self) -> ::windows_core::Result; fn SetMinimumClients(&self, ulminimumclients: u32) -> ::windows_core::Result<()>; fn StartTime(&self) -> ::windows_core::Result; fn SetStartTime(&self, starttime: f64) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespaceScheduledCastAutoStart {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespaceScheduledCastAutoStart_Vtbl { pub const fn new, Impl: IWdsTransportNamespaceScheduledCastAutoStart_Impl, const OFFSET: isize>() -> IWdsTransportNamespaceScheduledCastAutoStart_Vtbl { unsafe extern "system" fn MinimumClients, Impl: IWdsTransportNamespaceScheduledCastAutoStart_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulminimumclients: *mut u32) -> ::windows_core::HRESULT { @@ -1116,12 +1116,12 @@ impl IWdsTransportNamespaceScheduledCastAutoStart_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportNamespaceScheduledCastManualStart_Impl: Sized + IWdsTransportNamespaceScheduledCast_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportNamespaceScheduledCastManualStart {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportNamespaceScheduledCastManualStart_Vtbl { pub const fn new, Impl: IWdsTransportNamespaceScheduledCastManualStart_Impl, const OFFSET: isize>() -> IWdsTransportNamespaceScheduledCastManualStart_Vtbl { Self { base__: IWdsTransportNamespaceScheduledCast_Vtbl::new::() } @@ -1130,8 +1130,8 @@ impl IWdsTransportNamespaceScheduledCastManualStart_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportServer_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetupManager(&self) -> ::windows_core::Result; @@ -1139,9 +1139,9 @@ pub trait IWdsTransportServer_Impl: Sized + super::Com::IDispatch_Impl { fn NamespaceManager(&self) -> ::windows_core::Result; fn DisconnectClient(&self, ulclientid: u32, disconnectiontype: WDSTRANSPORT_DISCONNECT_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportServer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportServer_Vtbl { pub const fn new, Impl: IWdsTransportServer_Impl, const OFFSET: isize>() -> IWdsTransportServer_Vtbl { unsafe extern "system" fn Name, Impl: IWdsTransportServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1206,14 +1206,14 @@ impl IWdsTransportServer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportServer2_Impl: Sized + IWdsTransportServer_Impl { fn TftpManager(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportServer2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportServer2_Vtbl { pub const fn new, Impl: IWdsTransportServer2_Impl, const OFFSET: isize>() -> IWdsTransportServer2_Vtbl { unsafe extern "system" fn TftpManager, Impl: IWdsTransportServer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransporttftpmanager: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1233,8 +1233,8 @@ impl IWdsTransportServer2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportServicePolicy_Impl: Sized + IWdsTransportCacheable_Impl { fn get_IpAddressSource(&self, addresstype: WDSTRANSPORT_IP_ADDRESS_TYPE) -> ::windows_core::Result; fn put_IpAddressSource(&self, addresstype: WDSTRANSPORT_IP_ADDRESS_TYPE, sourcetype: WDSTRANSPORT_IP_ADDRESS_SOURCE_TYPE) -> ::windows_core::Result<()>; @@ -1249,9 +1249,9 @@ pub trait IWdsTransportServicePolicy_Impl: Sized + IWdsTransportCacheable_Impl { fn NetworkProfile(&self) -> ::windows_core::Result; fn SetNetworkProfile(&self, profiletype: WDSTRANSPORT_NETWORK_PROFILE_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportServicePolicy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportServicePolicy_Vtbl { pub const fn new, Impl: IWdsTransportServicePolicy_Impl, const OFFSET: isize>() -> IWdsTransportServicePolicy_Vtbl { unsafe extern "system" fn get_IpAddressSource, Impl: IWdsTransportServicePolicy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, addresstype: WDSTRANSPORT_IP_ADDRESS_TYPE, psourcetype: *mut WDSTRANSPORT_IP_ADDRESS_SOURCE_TYPE) -> ::windows_core::HRESULT { @@ -1370,8 +1370,8 @@ impl IWdsTransportServicePolicy_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportServicePolicy2_Impl: Sized + IWdsTransportServicePolicy_Impl { fn UdpPortPolicy(&self) -> ::windows_core::Result; fn SetUdpPortPolicy(&self, udpportpolicy: WDSTRANSPORT_UDP_PORT_POLICY) -> ::windows_core::Result<()>; @@ -1380,9 +1380,9 @@ pub trait IWdsTransportServicePolicy2_Impl: Sized + IWdsTransportServicePolicy_I fn EnableTftpVariableWindowExtension(&self) -> ::windows_core::Result; fn SetEnableTftpVariableWindowExtension(&self, benabletftpvariablewindowextension: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportServicePolicy2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportServicePolicy2_Vtbl { pub const fn new, Impl: IWdsTransportServicePolicy2_Impl, const OFFSET: isize>() -> IWdsTransportServicePolicy2_Vtbl { unsafe extern "system" fn UdpPortPolicy, Impl: IWdsTransportServicePolicy2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pudpportpolicy: *mut WDSTRANSPORT_UDP_PORT_POLICY) -> ::windows_core::HRESULT { @@ -1447,8 +1447,8 @@ impl IWdsTransportServicePolicy2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportSession_Impl: Sized + super::Com::IDispatch_Impl { fn Content(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; @@ -1459,9 +1459,9 @@ pub trait IWdsTransportSession_Impl: Sized + super::Com::IDispatch_Impl { fn RetrieveClients(&self) -> ::windows_core::Result; fn Terminate(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportSession_Vtbl { pub const fn new, Impl: IWdsTransportSession_Impl, const OFFSET: isize>() -> IWdsTransportSession_Vtbl { unsafe extern "system" fn Content, Impl: IWdsTransportSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransportcontent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1562,8 +1562,8 @@ impl IWdsTransportSession_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportSetupManager_Impl: Sized + super::Com::IDispatch_Impl { fn Version(&self) -> ::windows_core::Result; fn InstalledFeatures(&self) -> ::windows_core::Result; @@ -1571,9 +1571,9 @@ pub trait IWdsTransportSetupManager_Impl: Sized + super::Com::IDispatch_Impl { fn RegisterContentProvider(&self, bszname: &::windows_core::BSTR, bszdescription: &::windows_core::BSTR, bszfilepath: &::windows_core::BSTR, bszinitializationroutine: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DeregisterContentProvider(&self, bszname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportSetupManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportSetupManager_Vtbl { pub const fn new, Impl: IWdsTransportSetupManager_Impl, const OFFSET: isize>() -> IWdsTransportSetupManager_Vtbl { unsafe extern "system" fn Version, Impl: IWdsTransportSetupManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pullversion: *mut u64) -> ::windows_core::HRESULT { @@ -1632,15 +1632,15 @@ impl IWdsTransportSetupManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportSetupManager2_Impl: Sized + IWdsTransportSetupManager_Impl { fn TftpCapabilities(&self) -> ::windows_core::Result; fn ContentProviders(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportSetupManager2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportSetupManager2_Vtbl { pub const fn new, Impl: IWdsTransportSetupManager2_Impl, const OFFSET: isize>() -> IWdsTransportSetupManager2_Vtbl { unsafe extern "system" fn TftpCapabilities, Impl: IWdsTransportSetupManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pultftpcapabilities: *mut u32) -> ::windows_core::HRESULT { @@ -1675,8 +1675,8 @@ impl IWdsTransportSetupManager2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportTftpClient_Impl: Sized + super::Com::IDispatch_Impl { fn FileName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IpAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1686,9 +1686,9 @@ pub trait IWdsTransportTftpClient_Impl: Sized + super::Com::IDispatch_Impl { fn BlockSize(&self) -> ::windows_core::Result; fn WindowSize(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportTftpClient {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportTftpClient_Vtbl { pub const fn new, Impl: IWdsTransportTftpClient_Impl, const OFFSET: isize>() -> IWdsTransportTftpClient_Vtbl { unsafe extern "system" fn FileName, Impl: IWdsTransportTftpClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbszfilename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1783,14 +1783,14 @@ impl IWdsTransportTftpClient_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWdsTransportTftpManager_Impl: Sized + super::Com::IDispatch_Impl { fn RetrieveTftpClients(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWdsTransportTftpManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWdsTransportTftpManager_Vtbl { pub const fn new, Impl: IWdsTransportTftpManager_Impl, const OFFSET: isize>() -> IWdsTransportTftpManager_Vtbl { unsafe extern "system" fn RetrieveTftpClients, Impl: IWdsTransportTftpManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwdstransporttftpclients: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/impl.rs b/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/impl.rs index 38c83796f8..c2e29ba4e2 100644 --- a/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIApplication_Impl: Sized + super::Com::IDispatch_Impl { fn Windows(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; @@ -8,9 +8,9 @@ pub trait IRDPSRAPIApplication_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Flags(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIApplication_Vtbl { pub const fn new, Impl: IRDPSRAPIApplication_Impl, const OFFSET: isize>() -> IRDPSRAPIApplication_Vtbl { unsafe extern "system" fn Windows, Impl: IRDPSRAPIApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwindowlist: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -87,17 +87,17 @@ impl IRDPSRAPIApplication_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIApplicationFilter_Impl: Sized + super::Com::IDispatch_Impl { fn Applications(&self) -> ::windows_core::Result; fn Windows(&self) -> ::windows_core::Result; fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIApplicationFilter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIApplicationFilter_Vtbl { pub const fn new, Impl: IRDPSRAPIApplicationFilter_Impl, const OFFSET: isize>() -> IRDPSRAPIApplicationFilter_Vtbl { unsafe extern "system" fn Applications, Impl: IRDPSRAPIApplicationFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, papplications: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -150,15 +150,15 @@ impl IRDPSRAPIApplicationFilter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIApplicationList_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, item: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIApplicationList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIApplicationList_Vtbl { pub const fn new, Impl: IRDPSRAPIApplicationList_Impl, const OFFSET: isize>() -> IRDPSRAPIApplicationList_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IRDPSRAPIApplicationList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -193,8 +193,8 @@ impl IRDPSRAPIApplicationList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIAttendee_Impl: Sized + super::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result; fn RemoteName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -205,9 +205,9 @@ pub trait IRDPSRAPIAttendee_Impl: Sized + super::Com::IDispatch_Impl { fn Flags(&self) -> ::windows_core::Result; fn ConnectivityInfo(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIAttendee {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIAttendee_Vtbl { pub const fn new, Impl: IRDPSRAPIAttendee_Impl, const OFFSET: isize>() -> IRDPSRAPIAttendee_Vtbl { unsafe extern "system" fn Id, Impl: IRDPSRAPIAttendee_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut i32) -> ::windows_core::HRESULT { @@ -302,16 +302,16 @@ impl IRDPSRAPIAttendee_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIAttendeeDisconnectInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Attendee(&self) -> ::windows_core::Result; fn Reason(&self) -> ::windows_core::Result; fn Code(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIAttendeeDisconnectInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIAttendeeDisconnectInfo_Vtbl { pub const fn new, Impl: IRDPSRAPIAttendeeDisconnectInfo_Impl, const OFFSET: isize>() -> IRDPSRAPIAttendeeDisconnectInfo_Vtbl { unsafe extern "system" fn Attendee, Impl: IRDPSRAPIAttendeeDisconnectInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -358,15 +358,15 @@ impl IRDPSRAPIAttendeeDisconnectInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIAttendeeManager_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, id: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIAttendeeManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIAttendeeManager_Vtbl { pub const fn new, Impl: IRDPSRAPIAttendeeManager_Impl, const OFFSET: isize>() -> IRDPSRAPIAttendeeManager_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IRDPSRAPIAttendeeManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -515,17 +515,17 @@ impl IRDPSRAPIDebug_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIFrameBuffer_Impl: Sized + super::Com::IDispatch_Impl { fn Width(&self) -> ::windows_core::Result; fn Height(&self) -> ::windows_core::Result; fn Bpp(&self) -> ::windows_core::Result; fn GetFrameBufferBits(&self, x: i32, y: i32, width: i32, heigth: i32) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIFrameBuffer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIFrameBuffer_Vtbl { pub const fn new, Impl: IRDPSRAPIFrameBuffer_Impl, const OFFSET: isize>() -> IRDPSRAPIFrameBuffer_Vtbl { unsafe extern "system" fn Width, Impl: IRDPSRAPIFrameBuffer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plwidth: *mut i32) -> ::windows_core::HRESULT { @@ -584,8 +584,8 @@ impl IRDPSRAPIFrameBuffer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIInvitation_Impl: Sized + super::Com::IDispatch_Impl { fn ConnectionString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GroupName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -595,9 +595,9 @@ pub trait IRDPSRAPIInvitation_Impl: Sized + super::Com::IDispatch_Impl { fn Revoked(&self) -> ::windows_core::Result; fn SetRevoked(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIInvitation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIInvitation_Vtbl { pub const fn new, Impl: IRDPSRAPIInvitation_Impl, const OFFSET: isize>() -> IRDPSRAPIInvitation_Vtbl { unsafe extern "system" fn ConnectionString, Impl: IRDPSRAPIInvitation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -680,17 +680,17 @@ impl IRDPSRAPIInvitation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIInvitationManager_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, item: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, item: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn CreateInvitation(&self, bstrauthstring: &::windows_core::BSTR, bstrgroupname: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, attendeelimit: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIInvitationManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIInvitationManager_Vtbl { pub const fn new, Impl: IRDPSRAPIInvitationManager_Impl, const OFFSET: isize>() -> IRDPSRAPIInvitationManager_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IRDPSRAPIInvitationManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -704,7 +704,7 @@ impl IRDPSRAPIInvitationManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IRDPSRAPIInvitationManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: super::Variant::VARIANT, ppinvitation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IRDPSRAPIInvitationManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppinvitation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&item)) { @@ -789,18 +789,18 @@ impl IRDPSRAPIPerfCounterLoggingManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPISessionProperties_Impl: Sized + super::Com::IDispatch_Impl { - fn get_Property(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result; - fn put_Property(&self, propertyname: &::windows_core::BSTR, newval: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn get_Property(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn put_Property(&self, propertyname: &::windows_core::BSTR, newval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPISessionProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPISessionProperties_Vtbl { pub const fn new, Impl: IRDPSRAPISessionProperties_Impl, const OFFSET: isize>() -> IRDPSRAPISessionProperties_Vtbl { - unsafe extern "system" fn get_Property, Impl: IRDPSRAPISessionProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Property, Impl: IRDPSRAPISessionProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Property(::core::mem::transmute(&propertyname)) { @@ -811,7 +811,7 @@ impl IRDPSRAPISessionProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Property, Impl: IRDPSRAPISessionProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, newval: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Property, Impl: IRDPSRAPISessionProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Property(::core::mem::transmute(&propertyname), ::core::mem::transmute(&newval)).into() @@ -826,8 +826,8 @@ impl IRDPSRAPISessionProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPISharingSession_Impl: Sized + super::Com::IDispatch_Impl { fn Open(&self) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; @@ -844,9 +844,9 @@ pub trait IRDPSRAPISharingSession_Impl: Sized + super::Com::IDispatch_Impl { fn SetDesktopSharedRect(&self, left: i32, top: i32, right: i32, bottom: i32) -> ::windows_core::Result<()>; fn GetDesktopSharedRect(&self, pleft: *mut i32, ptop: *mut i32, pright: *mut i32, pbottom: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPISharingSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPISharingSession_Vtbl { pub const fn new, Impl: IRDPSRAPISharingSession_Impl, const OFFSET: isize>() -> IRDPSRAPISharingSession_Vtbl { unsafe extern "system" fn Open, Impl: IRDPSRAPISharingSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -977,16 +977,16 @@ impl IRDPSRAPISharingSession_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPISharingSession2_Impl: Sized + IRDPSRAPISharingSession_Impl { fn ConnectUsingTransportStream(&self, pstream: ::core::option::Option<&IRDPSRAPITransportStream>, bstrgroup: &::windows_core::BSTR, bstrauthenticatedattendeename: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FrameBuffer(&self) -> ::windows_core::Result; fn SendControlLevelChangeResponse(&self, pattendee: ::core::option::Option<&IRDPSRAPIAttendee>, requestedlevel: CTRL_LEVEL, reasoncode: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPISharingSession2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPISharingSession2_Vtbl { pub const fn new, Impl: IRDPSRAPISharingSession2_Impl, const OFFSET: isize>() -> IRDPSRAPISharingSession2_Vtbl { unsafe extern "system" fn ConnectUsingTransportStream, Impl: IRDPSRAPISharingSession2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstream: *mut ::core::ffi::c_void, bstrgroup: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrauthenticatedattendeename: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1021,8 +1021,8 @@ impl IRDPSRAPISharingSession2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPITcpConnectionInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Protocol(&self) -> ::windows_core::Result; fn LocalPort(&self) -> ::windows_core::Result; @@ -1030,9 +1030,9 @@ pub trait IRDPSRAPITcpConnectionInfo_Impl: Sized + super::Com::IDispatch_Impl { fn PeerPort(&self) -> ::windows_core::Result; fn PeerIP(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPITcpConnectionInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPITcpConnectionInfo_Vtbl { pub const fn new, Impl: IRDPSRAPITcpConnectionInfo_Impl, const OFFSET: isize>() -> IRDPSRAPITcpConnectionInfo_Vtbl { unsafe extern "system" fn Protocol, Impl: IRDPSRAPITcpConnectionInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plprotocol: *mut i32) -> ::windows_core::HRESULT { @@ -1317,8 +1317,8 @@ impl IRDPSRAPITransportStreamEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIViewer_Impl: Sized + super::Com::IDispatch_Impl { fn Connect(&self, bstrconnectionstring: &::windows_core::BSTR, bstrname: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Disconnect(&self) -> ::windows_core::Result<()>; @@ -1335,9 +1335,9 @@ pub trait IRDPSRAPIViewer_Impl: Sized + super::Com::IDispatch_Impl { fn Properties(&self) -> ::windows_core::Result; fn StartReverseConnectListener(&self, bstrconnectionstring: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIViewer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIViewer_Vtbl { pub const fn new, Impl: IRDPSRAPIViewer_Impl, const OFFSET: isize>() -> IRDPSRAPIViewer_Vtbl { unsafe extern "system" fn Connect, Impl: IRDPSRAPIViewer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrconnectionstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1480,8 +1480,8 @@ impl IRDPSRAPIViewer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIVirtualChannel_Impl: Sized + super::Com::IDispatch_Impl { fn SendData(&self, bstrdata: &::windows_core::BSTR, lattendeeid: i32, channelsendflags: u32) -> ::windows_core::Result<()>; fn SetAccess(&self, lattendeeid: i32, accesstype: CHANNEL_ACCESS_ENUM) -> ::windows_core::Result<()>; @@ -1489,9 +1489,9 @@ pub trait IRDPSRAPIVirtualChannel_Impl: Sized + super::Com::IDispatch_Impl { fn Flags(&self) -> ::windows_core::Result; fn Priority(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIVirtualChannel {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIVirtualChannel_Vtbl { pub const fn new, Impl: IRDPSRAPIVirtualChannel_Impl, const OFFSET: isize>() -> IRDPSRAPIVirtualChannel_Vtbl { unsafe extern "system" fn SendData, Impl: IRDPSRAPIVirtualChannel_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdata: ::std::mem::MaybeUninit<::windows_core::BSTR>, lattendeeid: i32, channelsendflags: u32) -> ::windows_core::HRESULT { @@ -1550,16 +1550,16 @@ impl IRDPSRAPIVirtualChannel_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIVirtualChannelManager_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, item: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, item: &::windows_core::VARIANT) -> ::windows_core::Result; fn CreateVirtualChannel(&self, bstrchannelname: &::windows_core::BSTR, priority: CHANNEL_PRIORITY, channelflags: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIVirtualChannelManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIVirtualChannelManager_Vtbl { pub const fn new, Impl: IRDPSRAPIVirtualChannelManager_Impl, const OFFSET: isize>() -> IRDPSRAPIVirtualChannelManager_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IRDPSRAPIVirtualChannelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1573,7 +1573,7 @@ impl IRDPSRAPIVirtualChannelManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IRDPSRAPIVirtualChannelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: super::Variant::VARIANT, pchannel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IRDPSRAPIVirtualChannelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pchannel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&item)) { @@ -1606,8 +1606,8 @@ impl IRDPSRAPIVirtualChannelManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIWindow_Impl: Sized + super::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result; fn Application(&self) -> ::windows_core::Result; @@ -1617,9 +1617,9 @@ pub trait IRDPSRAPIWindow_Impl: Sized + super::Com::IDispatch_Impl { fn Show(&self) -> ::windows_core::Result<()>; fn Flags(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIWindow {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIWindow_Vtbl { pub const fn new, Impl: IRDPSRAPIWindow_Impl, const OFFSET: isize>() -> IRDPSRAPIWindow_Vtbl { unsafe extern "system" fn Id, Impl: IRDPSRAPIWindow_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pretval: *mut i32) -> ::windows_core::HRESULT { @@ -1702,15 +1702,15 @@ impl IRDPSRAPIWindow_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRDPSRAPIWindowList_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn get_Item(&self, item: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRDPSRAPIWindowList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRDPSRAPIWindowList_Vtbl { pub const fn new, Impl: IRDPSRAPIWindowList_Impl, const OFFSET: isize>() -> IRDPSRAPIWindowList_Vtbl { unsafe extern "system" fn _NewEnum, Impl: IRDPSRAPIWindowList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1814,12 +1814,12 @@ impl IRDPViewerInputSink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IRDPSessionEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IRDPSessionEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IRDPSessionEvents_Vtbl { pub const fn new, Impl: _IRDPSessionEvents_Impl, const OFFSET: isize>() -> _IRDPSessionEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/mod.rs b/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/mod.rs index 03e023be68..0432cf394e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/DesktopSharing/mod.rs @@ -453,11 +453,14 @@ impl IRDPSRAPIInvitationManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, item: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, item: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(item), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), item.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -481,9 +484,9 @@ impl IRDPSRAPIInvitationManager { pub struct IRDPSRAPIInvitationManager_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: super::Variant::VARIANT, ppinvitation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppinvitation: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pretval: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -532,22 +535,19 @@ pub struct IRDPSRAPIPerfCounterLoggingManager_Vtbl { ::windows_core::imp::interface_hierarchy!(IRDPSRAPISessionProperties, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IRDPSRAPISessionProperties { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, propertyname: P0) -> ::windows_core::Result + pub unsafe fn get_Property(&self, propertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Property)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Property(&self, propertyname: P0, newval: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn put_Property(&self, propertyname: P0, newval: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), ::core::mem::transmute(newval)).ok() + (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), newval.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -555,14 +555,8 @@ impl IRDPSRAPISessionProperties { #[doc(hidden)] pub struct IRDPSRAPISessionProperties_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Property: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, newval: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_Property: usize, + pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, newval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1138,11 +1132,14 @@ impl IRDPSRAPIVirtualChannelManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, item: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, item: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(item), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), item.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1160,9 +1157,9 @@ impl IRDPSRAPIVirtualChannelManager { pub struct IRDPSRAPIVirtualChannelManager_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: super::Variant::VARIANT, pchannel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pchannel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub CreateVirtualChannel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrchannelname: ::std::mem::MaybeUninit<::windows_core::BSTR>, priority: CHANNEL_PRIORITY, channelflags: u32, ppchannel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/impl.rs index 4d541b66ac..4ba8e8a91e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/impl.rs @@ -657,16 +657,16 @@ impl IActiveScriptHostEncode_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IActiveScriptParse32_Impl: Sized { fn InitNew(&self) -> ::windows_core::Result<()>; fn AddScriptlet(&self, pstrdefaultname: &::windows_core::PCWSTR, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, pstrsubitemname: &::windows_core::PCWSTR, pstreventname: &::windows_core::PCWSTR, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pbstrname: *mut ::windows_core::BSTR, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; - fn ParseScriptText(&self, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, punkcontext: ::core::option::Option<&::windows_core::IUnknown>, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; + fn ParseScriptText(&self, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, punkcontext: ::core::option::Option<&::windows_core::IUnknown>, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IActiveScriptParse32 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IActiveScriptParse32_Vtbl { pub const fn new, Impl: IActiveScriptParse32_Impl, const OFFSET: isize>() -> IActiveScriptParse32_Vtbl { unsafe extern "system" fn InitNew, Impl: IActiveScriptParse32_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -680,7 +680,7 @@ impl IActiveScriptParse32_Vtbl { this.AddScriptlet(::core::mem::transmute(&pstrdefaultname), ::core::mem::transmute(&pstrcode), ::core::mem::transmute(&pstritemname), ::core::mem::transmute(&pstrsubitemname), ::core::mem::transmute(&pstreventname), ::core::mem::transmute(&pstrdelimiter), ::core::mem::transmute_copy(&dwsourcecontextcookie), ::core::mem::transmute_copy(&ulstartinglinenumber), ::core::mem::transmute_copy(&dwflags), ::core::mem::transmute_copy(&pbstrname), ::core::mem::transmute_copy(&pexcepinfo)) .into() } - unsafe extern "system" fn ParseScriptText, Impl: IActiveScriptParse32_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { + unsafe extern "system" fn ParseScriptText, Impl: IActiveScriptParse32_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ParseScriptText(::core::mem::transmute(&pstrcode), ::core::mem::transmute(&pstritemname), ::windows_core::from_raw_borrowed(&punkcontext), ::core::mem::transmute(&pstrdelimiter), ::core::mem::transmute_copy(&dwsourcecontextcookie), ::core::mem::transmute_copy(&ulstartinglinenumber), ::core::mem::transmute_copy(&dwflags), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo)).into() @@ -696,16 +696,16 @@ impl IActiveScriptParse32_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IActiveScriptParse64_Impl: Sized { fn InitNew(&self) -> ::windows_core::Result<()>; fn AddScriptlet(&self, pstrdefaultname: &::windows_core::PCWSTR, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, pstrsubitemname: &::windows_core::PCWSTR, pstreventname: &::windows_core::PCWSTR, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pbstrname: *mut ::windows_core::BSTR, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; - fn ParseScriptText(&self, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, punkcontext: ::core::option::Option<&::windows_core::IUnknown>, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; + fn ParseScriptText(&self, pstrcode: &::windows_core::PCWSTR, pstritemname: &::windows_core::PCWSTR, punkcontext: ::core::option::Option<&::windows_core::IUnknown>, pstrdelimiter: &::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IActiveScriptParse64 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IActiveScriptParse64_Vtbl { pub const fn new, Impl: IActiveScriptParse64_Impl, const OFFSET: isize>() -> IActiveScriptParse64_Vtbl { unsafe extern "system" fn InitNew, Impl: IActiveScriptParse64_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -719,7 +719,7 @@ impl IActiveScriptParse64_Vtbl { this.AddScriptlet(::core::mem::transmute(&pstrdefaultname), ::core::mem::transmute(&pstrcode), ::core::mem::transmute(&pstritemname), ::core::mem::transmute(&pstrsubitemname), ::core::mem::transmute(&pstreventname), ::core::mem::transmute(&pstrdelimiter), ::core::mem::transmute_copy(&dwsourcecontextcookie), ::core::mem::transmute_copy(&ulstartinglinenumber), ::core::mem::transmute_copy(&dwflags), ::core::mem::transmute_copy(&pbstrname), ::core::mem::transmute_copy(&pexcepinfo)) .into() } - unsafe extern "system" fn ParseScriptText, Impl: IActiveScriptParse64_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { + unsafe extern "system" fn ParseScriptText, Impl: IActiveScriptParse64_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ParseScriptText(::core::mem::transmute(&pstrcode), ::core::mem::transmute(&pstritemname), ::windows_core::from_raw_borrowed(&punkcontext), ::core::mem::transmute(&pstrdelimiter), ::core::mem::transmute_copy(&dwsourcecontextcookie), ::core::mem::transmute_copy(&ulstartinglinenumber), ::core::mem::transmute_copy(&dwflags), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo)).into() @@ -1135,18 +1135,14 @@ impl IActiveScriptProfilerHeapEnum_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IActiveScriptProperty_Impl: Sized { - fn GetProperty(&self, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result; - fn SetProperty(&self, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, dwproperty: u32, pvarindex: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetProperty(&self, dwproperty: u32, pvarindex: *const ::windows_core::VARIANT, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IActiveScriptProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IActiveScriptProperty_Vtbl { pub const fn new, Impl: IActiveScriptProperty_Impl, const OFFSET: isize>() -> IActiveScriptProperty_Vtbl { - unsafe extern "system" fn GetProperty, Impl: IActiveScriptProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IActiveScriptProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&dwproperty), ::core::mem::transmute_copy(&pvarindex)) { @@ -1157,7 +1153,7 @@ impl IActiveScriptProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetProperty, Impl: IActiveScriptProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *const super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetProperty, Impl: IActiveScriptProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetProperty(::core::mem::transmute_copy(&dwproperty), ::core::mem::transmute_copy(&pvarindex), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -1195,21 +1191,21 @@ impl IActiveScriptSIPInfo_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IActiveScriptSite_Impl: Sized { fn GetLCID(&self) -> ::windows_core::Result; fn GetItemInfo(&self, pstrname: &::windows_core::PCWSTR, dwreturnmask: u32, ppiunkitem: *mut ::core::option::Option<::windows_core::IUnknown>, ppti: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GetDocVersionString(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn OnScriptTerminate(&self, pvarresult: *const super::super::super::Variant::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; + fn OnScriptTerminate(&self, pvarresult: *const ::windows_core::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; fn OnStateChange(&self, ssscriptstate: SCRIPTSTATE) -> ::windows_core::Result<()>; fn OnScriptError(&self, pscripterror: ::core::option::Option<&IActiveScriptError>) -> ::windows_core::Result<()>; fn OnEnterScript(&self) -> ::windows_core::Result<()>; fn OnLeaveScript(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IActiveScriptSite {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IActiveScriptSite_Vtbl { pub const fn new, Impl: IActiveScriptSite_Impl, const OFFSET: isize>() -> IActiveScriptSite_Vtbl { unsafe extern "system" fn GetLCID, Impl: IActiveScriptSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcid: *mut u32) -> ::windows_core::HRESULT { @@ -1239,7 +1235,7 @@ impl IActiveScriptSite_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OnScriptTerminate, Impl: IActiveScriptSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarresult: *const super::super::super::Variant::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnScriptTerminate, Impl: IActiveScriptSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarresult: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnScriptTerminate(::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo)).into() @@ -3519,8 +3515,8 @@ impl IDebugExpressionContext_Vtbl { #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDebugFormatter_Impl: Sized { - fn GetStringForVariant(&self, pvar: *const super::super::super::Variant::VARIANT, nradix: u32) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetVariantForString(&self, pwstrvalue: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetStringForVariant(&self, pvar: *const ::windows_core::VARIANT, nradix: u32) -> ::windows_core::Result<::windows_core::BSTR>; + fn GetVariantForString(&self, pwstrvalue: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetStringForVarType(&self, vt: super::super::super::Variant::VARENUM, ptdescarraytype: *const super::super::super::Com::TYPEDESC) -> ::windows_core::Result<::windows_core::BSTR>; } #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] @@ -3528,7 +3524,7 @@ impl ::windows_core::RuntimeName for IDebugFormatter {} #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDebugFormatter_Vtbl { pub const fn new, Impl: IDebugFormatter_Impl, const OFFSET: isize>() -> IDebugFormatter_Vtbl { - unsafe extern "system" fn GetStringForVariant, Impl: IDebugFormatter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, nradix: u32, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetStringForVariant, Impl: IDebugFormatter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, nradix: u32, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetStringForVariant(::core::mem::transmute_copy(&pvar), ::core::mem::transmute_copy(&nradix)) { @@ -3539,7 +3535,7 @@ impl IDebugFormatter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetVariantForString, Impl: IDebugFormatter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwstrvalue: ::windows_core::PCWSTR, pvar: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetVariantForString, Impl: IDebugFormatter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pwstrvalue: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetVariantForString(::core::mem::transmute(&pwstrvalue)) { @@ -3572,19 +3568,19 @@ impl IDebugFormatter_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDebugHelper_Impl: Sized { - fn CreatePropertyBrowser(&self, pvar: *const super::super::super::Variant::VARIANT, bstrname: &::windows_core::PCWSTR, pdat: ::core::option::Option<&IDebugApplicationThread>) -> ::windows_core::Result; - fn CreatePropertyBrowserEx(&self, pvar: *const super::super::super::Variant::VARIANT, bstrname: &::windows_core::PCWSTR, pdat: ::core::option::Option<&IDebugApplicationThread>, pdf: ::core::option::Option<&IDebugFormatter>) -> ::windows_core::Result; + fn CreatePropertyBrowser(&self, pvar: *const ::windows_core::VARIANT, bstrname: &::windows_core::PCWSTR, pdat: ::core::option::Option<&IDebugApplicationThread>) -> ::windows_core::Result; + fn CreatePropertyBrowserEx(&self, pvar: *const ::windows_core::VARIANT, bstrname: &::windows_core::PCWSTR, pdat: ::core::option::Option<&IDebugApplicationThread>, pdf: ::core::option::Option<&IDebugFormatter>) -> ::windows_core::Result; fn CreateSimpleConnectionPoint(&self, pdisp: ::core::option::Option<&super::super::super::Com::IDispatch>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDebugHelper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDebugHelper_Vtbl { pub const fn new, Impl: IDebugHelper_Impl, const OFFSET: isize>() -> IDebugHelper_Vtbl { - unsafe extern "system" fn CreatePropertyBrowser, Impl: IDebugHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreatePropertyBrowser, Impl: IDebugHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreatePropertyBrowser(::core::mem::transmute_copy(&pvar), ::core::mem::transmute(&bstrname), ::windows_core::from_raw_borrowed(&pdat)) { @@ -3595,7 +3591,7 @@ impl IDebugHelper_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreatePropertyBrowserEx, Impl: IDebugHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, pdf: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreatePropertyBrowserEx, Impl: IDebugHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, pdf: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreatePropertyBrowserEx(::core::mem::transmute_copy(&pvar), ::core::mem::transmute(&bstrname), ::windows_core::from_raw_borrowed(&pdat), ::windows_core::from_raw_borrowed(&pdf)) { @@ -5776,17 +5772,17 @@ impl ISimpleConnectionPoint_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITridentEventSink_Impl: Sized { - fn FireEvent(&self, pstrevent: &::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut super::super::super::Variant::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; + fn FireEvent(&self, pstrevent: &::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut ::windows_core::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITridentEventSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITridentEventSink_Vtbl { pub const fn new, Impl: ITridentEventSink_Impl, const OFFSET: isize>() -> ITridentEventSink_Vtbl { - unsafe extern "system" fn FireEvent, Impl: ITridentEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrevent: ::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut super::super::super::Variant::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { + unsafe extern "system" fn FireEvent, Impl: ITridentEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstrevent: ::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.FireEvent(::core::mem::transmute(&pstrevent), ::core::mem::transmute_copy(&pdp), ::core::mem::transmute_copy(&pvarres), ::core::mem::transmute_copy(&pei)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/mod.rs index 09a5fa187d..01bdde1c9a 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/ActiveScript/mod.rs @@ -514,16 +514,16 @@ impl IActiveScriptParse32 { { (::windows_core::Interface::vtable(self).AddScriptlet)(::windows_core::Interface::as_raw(self), pstrdefaultname.into_param().abi(), pstrcode.into_param().abi(), pstritemname.into_param().abi(), pstrsubitemname.into_param().abi(), pstreventname.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, ::core::mem::transmute(pbstrname), pexcepinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ParseScriptText(&self, pstrcode: P0, pstritemname: P1, punkcontext: P2, pstrdelimiter: P3, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ParseScriptText(&self, pstrcode: P0, pstritemname: P1, punkcontext: P2, pstrdelimiter: P3, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, P2: ::windows_core::IntoParam<::windows_core::IUnknown>, P3: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).ParseScriptText)(::windows_core::Interface::as_raw(self), pstrcode.into_param().abi(), pstritemname.into_param().abi(), punkcontext.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, pvarresult, pexcepinfo).ok() + (::windows_core::Interface::vtable(self).ParseScriptText)(::windows_core::Interface::as_raw(self), pstrcode.into_param().abi(), pstritemname.into_param().abi(), punkcontext.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, ::core::mem::transmute(pvarresult), pexcepinfo).ok() } } #[repr(C)] @@ -535,9 +535,9 @@ pub struct IActiveScriptParse32_Vtbl { pub AddScriptlet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrdefaultname: ::windows_core::PCWSTR, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, pstrsubitemname: ::windows_core::PCWSTR, pstreventname: ::windows_core::PCWSTR, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddScriptlet: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ParseScriptText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ParseScriptText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ParseScriptText: usize, } ::windows_core::imp::com_interface!(IActiveScriptParse64, IActiveScriptParse64_Vtbl, 0xc7ef7658_e1ee_480e_97ea_d52cb4d76d17); @@ -559,16 +559,16 @@ impl IActiveScriptParse64 { { (::windows_core::Interface::vtable(self).AddScriptlet)(::windows_core::Interface::as_raw(self), pstrdefaultname.into_param().abi(), pstrcode.into_param().abi(), pstritemname.into_param().abi(), pstrsubitemname.into_param().abi(), pstreventname.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, ::core::mem::transmute(pbstrname), pexcepinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ParseScriptText(&self, pstrcode: P0, pstritemname: P1, punkcontext: P2, pstrdelimiter: P3, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ParseScriptText(&self, pstrcode: P0, pstritemname: P1, punkcontext: P2, pstrdelimiter: P3, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, P2: ::windows_core::IntoParam<::windows_core::IUnknown>, P3: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).ParseScriptText)(::windows_core::Interface::as_raw(self), pstrcode.into_param().abi(), pstritemname.into_param().abi(), punkcontext.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, pvarresult, pexcepinfo).ok() + (::windows_core::Interface::vtable(self).ParseScriptText)(::windows_core::Interface::as_raw(self), pstrcode.into_param().abi(), pstritemname.into_param().abi(), punkcontext.into_param().abi(), pstrdelimiter.into_param().abi(), dwsourcecontextcookie, ulstartinglinenumber, dwflags, ::core::mem::transmute(pvarresult), pexcepinfo).ok() } } #[repr(C)] @@ -580,9 +580,9 @@ pub struct IActiveScriptParse64_Vtbl { pub AddScriptlet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrdefaultname: ::windows_core::PCWSTR, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, pstrsubitemname: ::windows_core::PCWSTR, pstreventname: ::windows_core::PCWSTR, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddScriptlet: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ParseScriptText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut super::super::super::Variant::VARIANT, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ParseScriptText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrcode: ::windows_core::PCWSTR, pstritemname: ::windows_core::PCWSTR, punkcontext: *mut ::core::ffi::c_void, pstrdelimiter: ::windows_core::PCWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ParseScriptText: usize, } ::windows_core::imp::com_interface!(IActiveScriptParseProcedure2_32, IActiveScriptParseProcedure2_32_Vtbl, 0x71ee5b20_fb04_11d1_b3a8_00a0c911e8b2); @@ -1050,30 +1050,20 @@ pub struct IActiveScriptProfilerHeapEnum_Vtbl { ::windows_core::imp::com_interface!(IActiveScriptProperty, IActiveScriptProperty_Vtbl, 0x4954e0d0_fbc7_11d1_8410_006008c3fbfc); ::windows_core::imp::interface_hierarchy!(IActiveScriptProperty, ::windows_core::IUnknown); impl IActiveScriptProperty { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetProperty(&self, dwproperty: u32, pvarindex: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), dwproperty, pvarindex, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), dwproperty, ::core::mem::transmute(pvarindex), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetProperty(&self, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), dwproperty, pvarindex, pvarvalue).ok() + pub unsafe fn SetProperty(&self, dwproperty: u32, pvarindex: *const ::windows_core::VARIANT, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetProperty)(::windows_core::Interface::as_raw(self), dwproperty, ::core::mem::transmute(pvarindex), ::core::mem::transmute(pvarvalue)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IActiveScriptProperty_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const super::super::super::Variant::VARIANT, pvarvalue: *const super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwproperty: u32, pvarindex: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IActiveScriptSIPInfo, IActiveScriptSIPInfo_Vtbl, 0x764651d0_38de_11d4_a2a3_00104bd35090); ::windows_core::imp::interface_hierarchy!(IActiveScriptSIPInfo, ::windows_core::IUnknown); @@ -1108,10 +1098,10 @@ impl IActiveScriptSite { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDocVersionString)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnScriptTerminate(&self, pvarresult: *const super::super::super::Variant::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnScriptTerminate)(::windows_core::Interface::as_raw(self), pvarresult, pexcepinfo).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OnScriptTerminate(&self, pvarresult: *const ::windows_core::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnScriptTerminate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarresult), pexcepinfo).ok() } pub unsafe fn OnStateChange(&self, ssscriptstate: SCRIPTSTATE) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).OnStateChange)(::windows_core::Interface::as_raw(self), ssscriptstate).ok() @@ -1139,9 +1129,9 @@ pub struct IActiveScriptSite_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] GetItemInfo: usize, pub GetDocVersionString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrversion: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnScriptTerminate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarresult: *const super::super::super::Variant::VARIANT, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OnScriptTerminate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarresult: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *const super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OnScriptTerminate: usize, pub OnStateChange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ssscriptstate: SCRIPTSTATE) -> ::windows_core::HRESULT, pub OnScriptError: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pscripterror: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2895,15 +2885,11 @@ pub struct IDebugExpressionContext_Vtbl { ::windows_core::imp::com_interface!(IDebugFormatter, IDebugFormatter_Vtbl, 0x51973c05_cb0c_11d0_b5c9_00a0244a0e7a); ::windows_core::imp::interface_hierarchy!(IDebugFormatter, ::windows_core::IUnknown); impl IDebugFormatter { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetStringForVariant(&self, pvar: *const super::super::super::Variant::VARIANT, nradix: u32) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn GetStringForVariant(&self, pvar: *const ::windows_core::VARIANT, nradix: u32) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetStringForVariant)(::windows_core::Interface::as_raw(self), pvar, nradix, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetStringForVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), nradix, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetVariantForString(&self, pwstrvalue: P0) -> ::windows_core::Result + pub unsafe fn GetVariantForString(&self, pwstrvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -2921,14 +2907,8 @@ impl IDebugFormatter { #[doc(hidden)] pub struct IDebugFormatter_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetStringForVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, nradix: u32, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetStringForVariant: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetVariantForString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwstrvalue: ::windows_core::PCWSTR, pvar: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetVariantForString: usize, + pub GetStringForVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, nradix: u32, pbstrvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub GetVariantForString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pwstrvalue: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetStringForVarType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vt: super::super::super::Variant::VARENUM, ptdescarraytype: *const super::super::super::Com::TYPEDESC, pbstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] @@ -2937,26 +2917,22 @@ pub struct IDebugFormatter_Vtbl { ::windows_core::imp::com_interface!(IDebugHelper, IDebugHelper_Vtbl, 0x51973c3f_cb0c_11d0_b5c9_00a0244a0e7a); ::windows_core::imp::interface_hierarchy!(IDebugHelper, ::windows_core::IUnknown); impl IDebugHelper { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyBrowser(&self, pvar: *const super::super::super::Variant::VARIANT, bstrname: P0, pdat: P1) -> ::windows_core::Result + pub unsafe fn CreatePropertyBrowser(&self, pvar: *const ::windows_core::VARIANT, bstrname: P0, pdat: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreatePropertyBrowser)(::windows_core::Interface::as_raw(self), pvar, bstrname.into_param().abi(), pdat.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreatePropertyBrowser)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), bstrname.into_param().abi(), pdat.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyBrowserEx(&self, pvar: *const super::super::super::Variant::VARIANT, bstrname: P0, pdat: P1, pdf: P2) -> ::windows_core::Result + pub unsafe fn CreatePropertyBrowserEx(&self, pvar: *const ::windows_core::VARIANT, bstrname: P0, pdat: P1, pdf: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, P2: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreatePropertyBrowserEx)(::windows_core::Interface::as_raw(self), pvar, bstrname.into_param().abi(), pdat.into_param().abi(), pdf.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreatePropertyBrowserEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), bstrname.into_param().abi(), pdat.into_param().abi(), pdf.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2972,14 +2948,8 @@ impl IDebugHelper { #[doc(hidden)] pub struct IDebugHelper_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreatePropertyBrowser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreatePropertyBrowser: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreatePropertyBrowserEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::Variant::VARIANT, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, pdf: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreatePropertyBrowserEx: usize, + pub CreatePropertyBrowser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + pub CreatePropertyBrowserEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrname: ::windows_core::PCWSTR, pdat: *mut ::core::ffi::c_void, pdf: *mut ::core::ffi::c_void, ppdob: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateSimpleConnectionPoint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdisp: *mut ::core::ffi::c_void, ppscp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4432,22 +4402,22 @@ pub struct ISimpleConnectionPoint_Vtbl { ::windows_core::imp::com_interface!(ITridentEventSink, ITridentEventSink_Vtbl, 0x1dc9ca50_06ef_11d2_8415_006008c3fbfc); ::windows_core::imp::interface_hierarchy!(ITridentEventSink, ::windows_core::IUnknown); impl ITridentEventSink { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FireEvent(&self, pstrevent: P0, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut super::super::super::Variant::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn FireEvent(&self, pstrevent: P0, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut ::windows_core::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).FireEvent)(::windows_core::Interface::as_raw(self), pstrevent.into_param().abi(), pdp, pvarres, pei).ok() + (::windows_core::Interface::vtable(self).FireEvent)(::windows_core::Interface::as_raw(self), pstrevent.into_param().abi(), pdp, ::core::mem::transmute(pvarres), pei).ok() } } #[repr(C)] #[doc(hidden)] pub struct ITridentEventSink_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FireEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrevent: ::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut super::super::super::Variant::VARIANT, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub FireEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstrevent: ::windows_core::PCWSTR, pdp: *const super::super::super::Com::DISPPARAMS, pvarres: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pei: *mut super::super::super::Com::EXCEPINFO) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] FireEvent: usize, } ::windows_core::imp::com_interface!(IWebAppDiagnosticsObjectInitialization, IWebAppDiagnosticsObjectInitialization_Vtbl, 0x16ff3a42_a5f5_432b_b625_8e8e16f57e15); diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/impl.rs index 5a1c0eacfe..7800d77caf 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/impl.rs @@ -97,8 +97,6 @@ impl IDataModelConcept_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDataModelManager_Impl: Sized { fn Close(&self) -> ::windows_core::Result<()>; fn CreateNoValue(&self) -> ::windows_core::Result; @@ -107,8 +105,8 @@ pub trait IDataModelManager_Impl: Sized { fn CreateTypedObjectReference(&self, context: ::core::option::Option<&IDebugHostContext>, objectlocation: &Location, objecttype: ::core::option::Option<&IDebugHostType>) -> ::windows_core::Result; fn CreateSyntheticObject(&self, context: ::core::option::Option<&IDebugHostContext>) -> ::windows_core::Result; fn CreateDataModelObject(&self, datamodel: ::core::option::Option<&IDataModelConcept>) -> ::windows_core::Result; - fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result; - fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: ::core::option::Option<&IDebugHostType>) -> ::windows_core::Result; + fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const ::windows_core::VARIANT, r#type: ::core::option::Option<&IDebugHostType>) -> ::windows_core::Result; fn GetModelForTypeSignature(&self, typesignature: ::core::option::Option<&IDebugHostTypeSignature>) -> ::windows_core::Result; fn GetModelForType(&self, r#type: ::core::option::Option<&IDebugHostType>, datamodel: *mut ::core::option::Option, typesignature: *mut ::core::option::Option, wildcardmatches: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn RegisterModelForTypeSignature(&self, typesignature: ::core::option::Option<&IDebugHostTypeSignature>, datamodel: ::core::option::Option<&IModelObject>) -> ::windows_core::Result<()>; @@ -121,9 +119,7 @@ pub trait IDataModelManager_Impl: Sized { fn UnregisterNamedModel(&self, modelname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn AcquireNamedModel(&self, modelname: &::windows_core::PCWSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDataModelManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDataModelManager_Vtbl { pub const fn new, Impl: IDataModelManager_Impl, const OFFSET: isize>() -> IDataModelManager_Vtbl { unsafe extern "system" fn Close, Impl: IDataModelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -197,7 +193,7 @@ impl IDataModelManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateIntrinsicObject, Impl: IDataModelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objectkind: ModelObjectKind, intrinsicdata: *const super::super::super::Variant::VARIANT, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateIntrinsicObject, Impl: IDataModelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objectkind: ModelObjectKind, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateIntrinsicObject(::core::mem::transmute_copy(&objectkind), ::core::mem::transmute_copy(&intrinsicdata)) { @@ -208,7 +204,7 @@ impl IDataModelManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateTypedIntrinsicObject, Impl: IDataModelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTypedIntrinsicObject, Impl: IDataModelManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTypedIntrinsicObject(::core::mem::transmute_copy(&intrinsicdata), ::windows_core::from_raw_borrowed(&r#type)) { @@ -326,15 +322,11 @@ impl IDataModelManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDataModelManager2_Impl: Sized + IDataModelManager_Impl { fn AcquireSubNamespace(&self, modelname: &::windows_core::PCWSTR, subnamespacemodelname: &::windows_core::PCWSTR, accessname: &::windows_core::PCWSTR, metadata: ::core::option::Option<&IKeyStore>) -> ::windows_core::Result; - fn CreateTypedIntrinsicObjectEx(&self, context: ::core::option::Option<&IDebugHostContext>, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: ::core::option::Option<&IDebugHostType>) -> ::windows_core::Result; + fn CreateTypedIntrinsicObjectEx(&self, context: ::core::option::Option<&IDebugHostContext>, intrinsicdata: *const ::windows_core::VARIANT, r#type: ::core::option::Option<&IDebugHostType>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDataModelManager2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDataModelManager2_Vtbl { pub const fn new, Impl: IDataModelManager2_Impl, const OFFSET: isize>() -> IDataModelManager2_Vtbl { unsafe extern "system" fn AcquireSubNamespace, Impl: IDataModelManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, modelname: ::windows_core::PCWSTR, subnamespacemodelname: ::windows_core::PCWSTR, accessname: ::windows_core::PCWSTR, metadata: *mut ::core::ffi::c_void, namespacemodelobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -348,7 +340,7 @@ impl IDataModelManager2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateTypedIntrinsicObjectEx, Impl: IDataModelManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTypedIntrinsicObjectEx, Impl: IDataModelManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTypedIntrinsicObjectEx(::windows_core::from_raw_borrowed(&context), ::core::mem::transmute_copy(&intrinsicdata), ::windows_core::from_raw_borrowed(&r#type)) { @@ -17479,8 +17471,8 @@ impl IDebugFailureAnalysis2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Data_Xml_MsXml\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] pub trait IDebugFailureAnalysis3_Impl: Sized { fn GetFailureClass(&self) -> u32; fn GetFailureType(&self) -> DEBUG_FAILURE_TYPE; @@ -17506,9 +17498,9 @@ pub trait IDebugFailureAnalysis3_Impl: Sized { fn GetAnalysisXml(&self) -> ::windows_core::Result; fn AddStructuredAnalysisData(&self, tag: DEBUG_FLR_PARAM_TYPE, analysis: ::core::option::Option<&IDebugFailureAnalysis2>) -> ::windows_core::Result<()>; fn AddThreads(&self, pdebugfailurethreadenum: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; - fn AttributeGet(&self, nindex: u32) -> ::windows_core::Result; + fn AttributeGet(&self, nindex: u32) -> ::windows_core::Result<::windows_core::VARIANT>; fn AttributeGetName(&self, nindex: u32) -> ::windows_core::Result<::windows_core::BSTR>; - fn AttributeSet(&self, nindex: u32, value: &super::super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AttributeSet(&self, nindex: u32, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BlameApplication(&self, postfix: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn BlameProcess(&self, postfix: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn BlameThread(&self, pthread: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; @@ -17523,9 +17515,9 @@ pub trait IDebugFailureAnalysis3_Impl: Sized { fn GetAdditionalXML(&self, key: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::IUnknown>; fn DeleteAdditionalXML(&self, key: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IDebugFailureAnalysis3 {} -#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Data_Xml_MsXml", feature = "Win32_System_Com"))] impl IDebugFailureAnalysis3_Vtbl { pub const fn new, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>() -> IDebugFailureAnalysis3_Vtbl { unsafe extern "system" fn GetFailureClass, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> u32 { @@ -17660,7 +17652,7 @@ impl IDebugFailureAnalysis3_Vtbl { let this = (*this).get_impl(); this.AddThreads(::windows_core::from_raw_borrowed(&pdebugfailurethreadenum)).into() } - unsafe extern "system" fn AttributeGet, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvalue: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AttributeGet, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AttributeGet(::core::mem::transmute_copy(&nindex)) { @@ -17682,7 +17674,7 @@ impl IDebugFailureAnalysis3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AttributeSet, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, value: super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AttributeSet, Impl: IDebugFailureAnalysis3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, nindex: u32, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AttributeSet(::core::mem::transmute_copy(&nindex), ::core::mem::transmute(&value)).into() @@ -17887,17 +17879,13 @@ impl IDebugHostBaseClass_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDebugHostConstant_Impl: Sized + IDebugHostSymbol_Impl { - fn GetValue(&self) -> ::windows_core::Result; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDebugHostConstant {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDebugHostConstant_Vtbl { pub const fn new, Impl: IDebugHostConstant_Impl, const OFFSET: isize>() -> IDebugHostConstant_Vtbl { - unsafe extern "system" fn GetValue, Impl: IDebugHostConstant_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IDebugHostConstant_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -17937,16 +17925,12 @@ impl IDebugHostContext_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDebugHostData_Impl: Sized + IDebugHostSymbol_Impl { fn GetLocationKind(&self) -> ::windows_core::Result; fn GetLocation(&self) -> ::windows_core::Result; - fn GetValue(&self) -> ::windows_core::Result; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDebugHostData {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDebugHostData_Vtbl { pub const fn new, Impl: IDebugHostData_Impl, const OFFSET: isize>() -> IDebugHostData_Vtbl { unsafe extern "system" fn GetLocationKind, Impl: IDebugHostData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, locationkind: *mut LocationKind) -> ::windows_core::HRESULT { @@ -17971,7 +17955,7 @@ impl IDebugHostData_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IDebugHostData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IDebugHostData_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -18081,17 +18065,13 @@ impl IDebugHostExtensibility_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDebugHostField_Impl: Sized + IDebugHostSymbol_Impl { fn GetLocationKind(&self) -> ::windows_core::Result; fn GetOffset(&self) -> ::windows_core::Result; fn GetLocation(&self) -> ::windows_core::Result; - fn GetValue(&self) -> ::windows_core::Result; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDebugHostField {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDebugHostField_Vtbl { pub const fn new, Impl: IDebugHostField_Impl, const OFFSET: isize>() -> IDebugHostField_Vtbl { unsafe extern "system" fn GetLocationKind, Impl: IDebugHostField_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, locationkind: *mut LocationKind) -> ::windows_core::HRESULT { @@ -18127,7 +18107,7 @@ impl IDebugHostField_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IDebugHostField_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IDebugHostField_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -26313,13 +26293,13 @@ impl IModelMethod_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Variant\"`"] +#[cfg(feature = "Win32_System_Variant")] pub trait IModelObject_Impl: Sized { fn GetContext(&self) -> ::windows_core::Result; fn GetKind(&self) -> ::windows_core::Result; - fn GetIntrinsicValue(&self) -> ::windows_core::Result; - fn GetIntrinsicValueAs(&self, vt: super::super::super::Variant::VARENUM) -> ::windows_core::Result; + fn GetIntrinsicValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetIntrinsicValueAs(&self, vt: super::super::super::Variant::VARENUM) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetKeyValue(&self, key: &::windows_core::PCWSTR, object: *mut ::core::option::Option, metadata: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn SetKeyValue(&self, key: &::windows_core::PCWSTR, object: ::core::option::Option<&IModelObject>) -> ::windows_core::Result<()>; fn EnumerateKeyValues(&self) -> ::windows_core::Result; @@ -26350,9 +26330,9 @@ pub trait IModelObject_Impl: Sized { fn Compare(&self, other: ::core::option::Option<&IModelObject>, ppresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn IsEqualTo(&self, other: ::core::option::Option<&IModelObject>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::RuntimeName for IModelObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl IModelObject_Vtbl { pub const fn new, Impl: IModelObject_Impl, const OFFSET: isize>() -> IModelObject_Vtbl { unsafe extern "system" fn GetContext, Impl: IModelObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, context: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -26377,7 +26357,7 @@ impl IModelObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetIntrinsicValue, Impl: IModelObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intrinsicdata: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetIntrinsicValue, Impl: IModelObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intrinsicdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetIntrinsicValue() { @@ -26388,7 +26368,7 @@ impl IModelObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetIntrinsicValueAs, Impl: IModelObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vt: super::super::super::Variant::VARENUM, intrinsicdata: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetIntrinsicValueAs, Impl: IModelObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vt: super::super::super::Variant::VARENUM, intrinsicdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetIntrinsicValueAs(::core::mem::transmute_copy(&vt)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/mod.rs index eab9137cca..95fa3a7683 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/Extensions/mod.rs @@ -278,20 +278,16 @@ impl IDataModelManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateDataModelObject)(::windows_core::Interface::as_raw(self), datamodel.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateIntrinsicObject)(::windows_core::Interface::as_raw(self), objectkind, intrinsicdata, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateIntrinsicObject)(::windows_core::Interface::as_raw(self), objectkind, ::core::mem::transmute(intrinsicdata), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: P0) -> ::windows_core::Result + pub unsafe fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const ::windows_core::VARIANT, r#type: P0) -> ::windows_core::Result where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateTypedIntrinsicObject)(::windows_core::Interface::as_raw(self), intrinsicdata, r#type.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateTypedIntrinsicObject)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetModelForTypeSignature(&self, typesignature: P0) -> ::windows_core::Result where @@ -377,14 +373,8 @@ pub struct IDataModelManager_Vtbl { pub CreateTypedObjectReference: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, objectlocation: Location, objecttype: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateSyntheticObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateDataModelObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, datamodel: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateIntrinsicObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectkind: ModelObjectKind, intrinsicdata: *const super::super::super::Variant::VARIANT, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateIntrinsicObject: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTypedIntrinsicObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTypedIntrinsicObject: usize, + pub CreateIntrinsicObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objectkind: ModelObjectKind, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + pub CreateTypedIntrinsicObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetModelForTypeSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typesignature: *mut ::core::ffi::c_void, datamodel: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetModelForType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut ::core::ffi::c_void, datamodel: *mut *mut ::core::ffi::c_void, typesignature: *mut *mut ::core::ffi::c_void, wildcardmatches: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RegisterModelForTypeSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, typesignature: *mut ::core::ffi::c_void, datamodel: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -444,20 +434,16 @@ impl IDataModelManager2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CreateDataModelObject)(::windows_core::Interface::as_raw(self), datamodel.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const super::super::super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateIntrinsicObject)(::windows_core::Interface::as_raw(self), objectkind, intrinsicdata, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateIntrinsicObject)(::windows_core::Interface::as_raw(self), objectkind, ::core::mem::transmute(intrinsicdata), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: P0) -> ::windows_core::Result + pub unsafe fn CreateTypedIntrinsicObject(&self, intrinsicdata: *const ::windows_core::VARIANT, r#type: P0) -> ::windows_core::Result where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreateTypedIntrinsicObject)(::windows_core::Interface::as_raw(self), intrinsicdata, r#type.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreateTypedIntrinsicObject)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetModelForTypeSignature(&self, typesignature: P0) -> ::windows_core::Result where @@ -541,15 +527,13 @@ impl IDataModelManager2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AcquireSubNamespace)(::windows_core::Interface::as_raw(self), modelname.into_param().abi(), subnamespacemodelname.into_param().abi(), accessname.into_param().abi(), metadata.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTypedIntrinsicObjectEx(&self, context: P0, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: P1) -> ::windows_core::Result + pub unsafe fn CreateTypedIntrinsicObjectEx(&self, context: P0, intrinsicdata: *const ::windows_core::VARIANT, r#type: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateTypedIntrinsicObjectEx)(::windows_core::Interface::as_raw(self), context.into_param().abi(), intrinsicdata, r#type.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateTypedIntrinsicObjectEx)(::windows_core::Interface::as_raw(self), context.into_param().abi(), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] @@ -557,10 +541,7 @@ impl IDataModelManager2 { pub struct IDataModelManager2_Vtbl { pub base__: IDataModelManager_Vtbl, pub AcquireSubNamespace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, modelname: ::windows_core::PCWSTR, subnamespacemodelname: ::windows_core::PCWSTR, accessname: ::windows_core::PCWSTR, metadata: *mut ::core::ffi::c_void, namespacemodelobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTypedIntrinsicObjectEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, intrinsicdata: *const super::super::super::Variant::VARIANT, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTypedIntrinsicObjectEx: usize, + pub CreateTypedIntrinsicObjectEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut ::core::ffi::c_void, intrinsicdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: *mut ::core::ffi::c_void, object: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDataModelNameBinder, IDataModelNameBinder_Vtbl, 0xaf352b7b_8292_4c01_b360_2dc3696c65e7); ::windows_core::imp::interface_hierarchy!(IDataModelNameBinder, ::windows_core::IUnknown); @@ -12124,9 +12105,7 @@ impl IDebugFailureAnalysis3 { { (::windows_core::Interface::vtable(self).AddThreads)(::windows_core::Interface::as_raw(self), pdebugfailurethreadenum.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AttributeGet(&self, nindex: u32) -> ::windows_core::Result { + pub unsafe fn AttributeGet(&self, nindex: u32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AttributeGet)(::windows_core::Interface::as_raw(self), nindex, &mut result__).from_abi(result__) } @@ -12134,10 +12113,11 @@ impl IDebugFailureAnalysis3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AttributeGetName)(::windows_core::Interface::as_raw(self), nindex, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AttributeSet(&self, nindex: u32, value: super::super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AttributeSet)(::windows_core::Interface::as_raw(self), nindex, ::core::mem::transmute(value)).ok() + pub unsafe fn AttributeSet(&self, nindex: u32, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).AttributeSet)(::windows_core::Interface::as_raw(self), nindex, value.into_param().abi()).ok() } pub unsafe fn BlameApplication(&self, postfix: P0) -> ::windows_core::Result<()> where @@ -12238,15 +12218,9 @@ pub struct IDebugFailureAnalysis3_Vtbl { GetAnalysisXml: usize, pub AddStructuredAnalysisData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tag: DEBUG_FLR_PARAM_TYPE, analysis: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub AddThreads: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdebugfailurethreadenum: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AttributeGet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvalue: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AttributeGet: usize, + pub AttributeGet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AttributeGetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AttributeSet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, value: super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AttributeSet: usize, + pub AttributeSet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BlameApplication: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, postfix: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BlameProcess: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, postfix: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BlameThread: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pthread: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -12370,9 +12344,7 @@ impl IDebugHostConstant { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CompareAgainst)(::windows_core::Interface::as_raw(self), pcomparisonsymbol.into_param().abi(), comparisonflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -12381,10 +12353,7 @@ impl IDebugHostConstant { #[doc(hidden)] pub struct IDebugHostConstant_Vtbl { pub base__: IDebugHostSymbol_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDebugHostContext, IDebugHostContext_Vtbl, 0xa68c70d8_5ec0_46e5_b775_3134a48ea2e3); ::windows_core::imp::interface_hierarchy!(IDebugHostContext, ::windows_core::IUnknown); @@ -12448,9 +12417,7 @@ impl IDebugHostData { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetLocation)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -12461,10 +12428,7 @@ pub struct IDebugHostData_Vtbl { pub base__: IDebugHostSymbol_Vtbl, pub GetLocationKind: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, locationkind: *mut LocationKind) -> ::windows_core::HRESULT, pub GetLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: *mut Location) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDebugHostErrorSink, IDebugHostErrorSink_Vtbl, 0xc8ff0f0b_fce9_467e_8bb3_5d69ef109c00); ::windows_core::imp::interface_hierarchy!(IDebugHostErrorSink, ::windows_core::IUnknown); @@ -12615,9 +12579,7 @@ impl IDebugHostField { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetLocation)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -12629,10 +12591,7 @@ pub struct IDebugHostField_Vtbl { pub GetLocationKind: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, locationkind: *mut LocationKind) -> ::windows_core::HRESULT, pub GetOffset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, offset: *mut u64) -> ::windows_core::HRESULT, pub GetLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, location: *mut Location) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDebugHostMemory, IDebugHostMemory_Vtbl, 0x212149c9_9183_4a3e_b00e_4fd1dc95339b); ::windows_core::imp::interface_hierarchy!(IDebugHostMemory, ::windows_core::IUnknown); @@ -17955,15 +17914,13 @@ impl IModelObject { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetKind)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetIntrinsicValue(&self) -> ::windows_core::Result { + pub unsafe fn GetIntrinsicValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetIntrinsicValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetIntrinsicValueAs(&self, vt: super::super::super::Variant::VARENUM) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] + pub unsafe fn GetIntrinsicValueAs(&self, vt: super::super::super::Variant::VARENUM) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetIntrinsicValueAs)(::windows_core::Interface::as_raw(self), vt, &mut result__).from_abi(result__) } @@ -18123,13 +18080,10 @@ pub struct IModelObject_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetKind: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, kind: *mut ModelObjectKind) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetIntrinsicValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intrinsicdata: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetIntrinsicValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetIntrinsicValueAs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vt: super::super::super::Variant::VARENUM, intrinsicdata: *mut super::super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub GetIntrinsicValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intrinsicdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Variant")] + pub GetIntrinsicValueAs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vt: super::super::super::Variant::VARENUM, intrinsicdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Variant"))] GetIntrinsicValueAs: usize, pub GetKeyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: ::windows_core::PCWSTR, object: *mut *mut ::core::ffi::c_void, metadata: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetKeyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: ::windows_core::PCWSTR, object: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/impl.rs index 708e6235a4..1dc653a009 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/impl.rs @@ -1,12 +1,12 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IDebugExtendedProperty_Impl: Sized + IDebugProperty_Impl { fn GetExtendedPropertyInfo(&self, dwfieldspec: u32, nradix: u32, pextendedpropertyinfo: *mut ExtendedDebugPropertyInfo) -> ::windows_core::Result<()>; fn EnumExtendedMembers(&self, dwfieldspec: u32, nradix: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IDebugExtendedProperty {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IDebugExtendedProperty_Vtbl { pub const fn new, Impl: IDebugExtendedProperty_Impl, const OFFSET: isize>() -> IDebugExtendedProperty_Vtbl { unsafe extern "system" fn GetExtendedPropertyInfo, Impl: IDebugExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, pextendedpropertyinfo: *mut ExtendedDebugPropertyInfo) -> ::windows_core::HRESULT { @@ -35,18 +35,14 @@ impl IDebugExtendedProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDebugProperty_Impl: Sized { fn GetPropertyInfo(&self, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut DebugPropertyInfo) -> ::windows_core::Result<()>; - fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetValueAsString(&self, pszvalue: &::windows_core::PCWSTR, nradix: u32) -> ::windows_core::Result<()>; fn EnumMembers(&self, dwfieldspec: u32, nradix: u32, refiid: *const ::windows_core::GUID) -> ::windows_core::Result; fn GetParent(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDebugProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDebugProperty_Vtbl { pub const fn new, Impl: IDebugProperty_Impl, const OFFSET: isize>() -> IDebugProperty_Vtbl { unsafe extern "system" fn GetPropertyInfo, Impl: IDebugProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut DebugPropertyInfo) -> ::windows_core::HRESULT { @@ -54,7 +50,7 @@ impl IDebugProperty_Vtbl { let this = (*this).get_impl(); this.GetPropertyInfo(::core::mem::transmute_copy(&dwfieldspec), ::core::mem::transmute_copy(&nradix), ::core::mem::transmute_copy(&ppropertyinfo)).into() } - unsafe extern "system" fn GetExtendedInfo, Impl: IDebugProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetExtendedInfo, Impl: IDebugProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetExtendedInfo(::core::mem::transmute_copy(&cinfos), ::core::mem::transmute_copy(&rgguidextendedinfo), ::core::mem::transmute_copy(&rgvar)).into() @@ -162,8 +158,8 @@ impl IDebugPropertyEnumType_Registers_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait IEnumDebugExtendedPropertyInfo_Impl: Sized { fn Next(&self, celt: u32, rgextendedpropertyinfo: *mut ExtendedDebugPropertyInfo, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; @@ -171,9 +167,9 @@ pub trait IEnumDebugExtendedPropertyInfo_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn GetCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for IEnumDebugExtendedPropertyInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl IEnumDebugExtendedPropertyInfo_Vtbl { pub const fn new, Impl: IEnumDebugExtendedPropertyInfo_Impl, const OFFSET: isize>() -> IEnumDebugExtendedPropertyInfo_Vtbl { unsafe extern "system" fn Next, Impl: IEnumDebugExtendedPropertyInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgextendedpropertyinfo: *mut ExtendedDebugPropertyInfo, pceltfetched: *mut u32) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/mod.rs index 5d9388b7de..0a20d77c6e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Diagnostics/Debug/mod.rs @@ -2658,10 +2658,8 @@ impl IDebugExtendedProperty { pub unsafe fn GetPropertyInfo(&self, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut DebugPropertyInfo) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetPropertyInfo)(::windows_core::Interface::as_raw(self), dwfieldspec, nradix, ppropertyinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetExtendedInfo)(::windows_core::Interface::as_raw(self), cinfos, rgguidextendedinfo, rgvar).ok() + pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetExtendedInfo)(::windows_core::Interface::as_raw(self), cinfos, rgguidextendedinfo, ::core::mem::transmute(rgvar)).ok() } pub unsafe fn SetValueAsString(&self, pszvalue: P0, nradix: u32) -> ::windows_core::Result<()> where @@ -2677,8 +2675,8 @@ impl IDebugExtendedProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetParent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] pub unsafe fn GetExtendedPropertyInfo(&self, dwfieldspec: u32, nradix: u32, pextendedpropertyinfo: *mut ExtendedDebugPropertyInfo) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetExtendedPropertyInfo)(::windows_core::Interface::as_raw(self), dwfieldspec, nradix, pextendedpropertyinfo).ok() } @@ -2691,9 +2689,9 @@ impl IDebugExtendedProperty { #[doc(hidden)] pub struct IDebugExtendedProperty_Vtbl { pub base__: IDebugProperty_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] pub GetExtendedPropertyInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, pextendedpropertyinfo: *mut ExtendedDebugPropertyInfo) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] GetExtendedPropertyInfo: usize, pub EnumExtendedMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, ppeepi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -2703,10 +2701,8 @@ impl IDebugProperty { pub unsafe fn GetPropertyInfo(&self, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut DebugPropertyInfo) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetPropertyInfo)(::windows_core::Interface::as_raw(self), dwfieldspec, nradix, ppropertyinfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetExtendedInfo)(::windows_core::Interface::as_raw(self), cinfos, rgguidextendedinfo, rgvar).ok() + pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetExtendedInfo)(::windows_core::Interface::as_raw(self), cinfos, rgguidextendedinfo, ::core::mem::transmute(rgvar)).ok() } pub unsafe fn SetValueAsString(&self, pszvalue: P0, nradix: u32) -> ::windows_core::Result<()> where @@ -2728,10 +2724,7 @@ impl IDebugProperty { pub struct IDebugProperty_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetPropertyInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut DebugPropertyInfo) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetExtendedInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetExtendedInfo: usize, + pub GetExtendedInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cinfos: u32, rgguidextendedinfo: *const ::windows_core::GUID, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetValueAsString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszvalue: ::windows_core::PCWSTR, nradix: u32) -> ::windows_core::HRESULT, pub EnumMembers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwfieldspec: u32, nradix: u32, refiid: *const ::windows_core::GUID, ppepi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetParent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppdebugprop: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2805,8 +2798,8 @@ pub struct IDebugPropertyEnumType_Registers_Vtbl { ::windows_core::imp::com_interface!(IEnumDebugExtendedPropertyInfo, IEnumDebugExtendedPropertyInfo_Vtbl, 0x51973c53_cb0c_11d0_b5c9_00a0244a0e7a); ::windows_core::imp::interface_hierarchy!(IEnumDebugExtendedPropertyInfo, ::windows_core::IUnknown); impl IEnumDebugExtendedPropertyInfo { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] pub unsafe fn Next(&self, rgextendedpropertyinfo: &mut [ExtendedDebugPropertyInfo], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgextendedpropertyinfo.len().try_into().unwrap(), ::core::mem::transmute(rgextendedpropertyinfo.as_ptr()), pceltfetched).ok() } @@ -2829,9 +2822,9 @@ impl IEnumDebugExtendedPropertyInfo { #[doc(hidden)] pub struct IEnumDebugExtendedPropertyInfo_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgextendedpropertyinfo: *mut ExtendedDebugPropertyInfo, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] Next: usize, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -7286,8 +7279,8 @@ impl ::core::default::Default for EXIT_THREAD_DEBUG_INFO { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub struct ExtendedDebugPropertyInfo { pub dwValidFields: u32, pub pszName: ::windows_core::PWSTR, @@ -7298,21 +7291,35 @@ pub struct ExtendedDebugPropertyInfo { pub pDebugProp: ::std::mem::ManuallyDrop<::core::option::Option>, pub nDISPID: u32, pub nType: u32, - pub varValue: super::super::Variant::VARIANT, + pub varValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub plbValue: ::std::mem::ManuallyDrop<::core::option::Option>, pub pDebugExtProp: ::std::mem::ManuallyDrop<::core::option::Option>, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::core::clone::Clone for ExtendedDebugPropertyInfo { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] +impl ::core::fmt::Debug for ExtendedDebugPropertyInfo { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("ExtendedDebugPropertyInfo").field("dwValidFields", &self.dwValidFields).field("pszName", &self.pszName).field("pszType", &self.pszType).field("pszValue", &self.pszValue).field("pszFullName", &self.pszFullName).field("dwAttrib", &self.dwAttrib).field("pDebugProp", &self.pDebugProp).field("nDISPID", &self.nDISPID).field("nType", &self.nType).field("varValue", &self.varValue).field("plbValue", &self.plbValue).field("pDebugExtProp", &self.pDebugExtProp).finish() + } +} +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::TypeKind for ExtendedDebugPropertyInfo { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] +impl ::core::cmp::PartialEq for ExtendedDebugPropertyInfo { + fn eq(&self, other: &Self) -> bool { + self.dwValidFields == other.dwValidFields && self.pszName == other.pszName && self.pszType == other.pszType && self.pszValue == other.pszValue && self.pszFullName == other.pszFullName && self.dwAttrib == other.dwAttrib && self.pDebugProp == other.pDebugProp && self.nDISPID == other.nDISPID && self.nType == other.nType && self.varValue == other.varValue && self.plbValue == other.plbValue && self.pDebugExtProp == other.pDebugExtProp + } +} +#[cfg(feature = "Win32_System_Com_StructuredStorage")] +impl ::core::cmp::Eq for ExtendedDebugPropertyInfo {} +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::core::default::Default for ExtendedDebugPropertyInfo { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/System/EventNotificationService/impl.rs b/crates/libs/windows/src/Windows/Win32/System/EventNotificationService/impl.rs index 29601c1c37..c930481c9f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/EventNotificationService/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/EventNotificationService/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISensLogon_Impl: Sized + super::Com::IDispatch_Impl { fn Logon(&self, bstrusername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Logoff(&self, bstrusername: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -9,9 +9,9 @@ pub trait ISensLogon_Impl: Sized + super::Com::IDispatch_Impl { fn StartScreenSaver(&self, bstrusername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn StopScreenSaver(&self, bstrusername: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISensLogon {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISensLogon_Vtbl { pub const fn new, Impl: ISensLogon_Impl, const OFFSET: isize>() -> ISensLogon_Vtbl { unsafe extern "system" fn Logon, Impl: ISensLogon_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -64,8 +64,8 @@ impl ISensLogon_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISensLogon2_Impl: Sized + super::Com::IDispatch_Impl { fn Logon(&self, bstrusername: &::windows_core::BSTR, dwsessionid: u32) -> ::windows_core::Result<()>; fn Logoff(&self, bstrusername: &::windows_core::BSTR, dwsessionid: u32) -> ::windows_core::Result<()>; @@ -73,9 +73,9 @@ pub trait ISensLogon2_Impl: Sized + super::Com::IDispatch_Impl { fn SessionReconnect(&self, bstrusername: &::windows_core::BSTR, dwsessionid: u32) -> ::windows_core::Result<()>; fn PostShell(&self, bstrusername: &::windows_core::BSTR, dwsessionid: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISensLogon2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISensLogon2_Vtbl { pub const fn new, Impl: ISensLogon2_Impl, const OFFSET: isize>() -> ISensLogon2_Vtbl { unsafe extern "system" fn Logon, Impl: ISensLogon2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwsessionid: u32) -> ::windows_core::HRESULT { @@ -116,8 +116,8 @@ impl ISensLogon2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISensNetwork_Impl: Sized + super::Com::IDispatch_Impl { fn ConnectionMade(&self, bstrconnection: &::windows_core::BSTR, ultype: u32, lpqocinfo: *const SENS_QOCINFO) -> ::windows_core::Result<()>; fn ConnectionMadeNoQOCInfo(&self, bstrconnection: &::windows_core::BSTR, ultype: u32) -> ::windows_core::Result<()>; @@ -125,9 +125,9 @@ pub trait ISensNetwork_Impl: Sized + super::Com::IDispatch_Impl { fn DestinationReachable(&self, bstrdestination: &::windows_core::BSTR, bstrconnection: &::windows_core::BSTR, ultype: u32, lpqocinfo: *const SENS_QOCINFO) -> ::windows_core::Result<()>; fn DestinationReachableNoQOCInfo(&self, bstrdestination: &::windows_core::BSTR, bstrconnection: &::windows_core::BSTR, ultype: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISensNetwork {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISensNetwork_Vtbl { pub const fn new, Impl: ISensNetwork_Impl, const OFFSET: isize>() -> ISensNetwork_Vtbl { unsafe extern "system" fn ConnectionMade, Impl: ISensNetwork_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrconnection: ::std::mem::MaybeUninit<::windows_core::BSTR>, ultype: u32, lpqocinfo: *const SENS_QOCINFO) -> ::windows_core::HRESULT { @@ -168,16 +168,16 @@ impl ISensNetwork_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISensOnNow_Impl: Sized + super::Com::IDispatch_Impl { fn OnACPower(&self) -> ::windows_core::Result<()>; fn OnBatteryPower(&self, dwbatterylifepercent: u32) -> ::windows_core::Result<()>; fn BatteryLow(&self, dwbatterylifepercent: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISensOnNow {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISensOnNow_Vtbl { pub const fn new, Impl: ISensOnNow_Impl, const OFFSET: isize>() -> ISensOnNow_Vtbl { unsafe extern "system" fn OnACPower, Impl: ISensOnNow_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/impl.rs b/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/impl.rs index 8da4a8da8d..289de219f3 100644 --- a/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/impl.rs @@ -78,8 +78,8 @@ impl IGPEInformation_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPM_Impl: Sized + super::Com::IDispatch_Impl { fn GetDomain(&self, bstrdomain: &::windows_core::BSTR, bstrdomaincontroller: &::windows_core::BSTR, ldcflags: i32) -> ::windows_core::Result; fn GetBackupDir(&self, bstrbackupdir: &::windows_core::BSTR) -> ::windows_core::Result; @@ -94,9 +94,9 @@ pub trait IGPM_Impl: Sized + super::Com::IDispatch_Impl { fn CreateMigrationTable(&self) -> ::windows_core::Result; fn InitializeReporting(&self, bstradmpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPM {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPM_Vtbl { pub const fn new, Impl: IGPM_Impl, const OFFSET: isize>() -> IGPM_Vtbl { unsafe extern "system" fn GetDomain, Impl: IGPM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdomain: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdomaincontroller: ::std::mem::MaybeUninit<::windows_core::BSTR>, ldcflags: i32, pigpmdomain: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -245,15 +245,15 @@ impl IGPM_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPM2_Impl: Sized + IGPM_Impl { fn GetBackupDirEx(&self, bstrbackupdir: &::windows_core::BSTR, backupdirtype: GPMBackupType) -> ::windows_core::Result; fn InitializeReportingEx(&self, bstradmpath: &::windows_core::BSTR, reportingoptions: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPM2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPM2_Vtbl { pub const fn new, Impl: IGPM2_Impl, const OFFSET: isize>() -> IGPM2_Vtbl { unsafe extern "system" fn GetBackupDirEx, Impl: IGPM2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, backupdirtype: GPMBackupType, ppigpmbackupdirex: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -282,14 +282,14 @@ impl IGPM2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMAsyncCancel_Impl: Sized + super::Com::IDispatch_Impl { fn Cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMAsyncCancel {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMAsyncCancel_Vtbl { pub const fn new, Impl: IGPMAsyncCancel_Impl, const OFFSET: isize>() -> IGPMAsyncCancel_Vtbl { unsafe extern "system" fn Cancel, Impl: IGPMAsyncCancel_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -303,17 +303,17 @@ impl IGPMAsyncCancel_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMAsyncProgress_Impl: Sized + super::Com::IDispatch_Impl { - fn Status(&self, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const super::Variant::VARIANT, ppigpmstatusmsgcollection: ::core::option::Option<&IGPMStatusMsgCollection>) -> ::windows_core::Result<()>; + fn Status(&self, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const ::windows_core::VARIANT, ppigpmstatusmsgcollection: ::core::option::Option<&IGPMStatusMsgCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMAsyncProgress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMAsyncProgress_Vtbl { pub const fn new, Impl: IGPMAsyncProgress_Impl, const OFFSET: isize>() -> IGPMAsyncProgress_Vtbl { - unsafe extern "system" fn Status, Impl: IGPMAsyncProgress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const super::Variant::VARIANT, ppigpmstatusmsgcollection: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Status, Impl: IGPMAsyncProgress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmstatusmsgcollection: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Status(::core::mem::transmute_copy(&lprogressnumerator), ::core::mem::transmute_copy(&lprogressdenominator), ::core::mem::transmute_copy(&hrstatus), ::core::mem::transmute_copy(&presult), ::windows_core::from_raw_borrowed(&ppigpmstatusmsgcollection)).into() @@ -324,8 +324,8 @@ impl IGPMAsyncProgress_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMBackup_Impl: Sized + super::Com::IDispatch_Impl { fn ID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GPOID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -335,12 +335,12 @@ pub trait IGPMBackup_Impl: Sized + super::Com::IDispatch_Impl { fn Comment(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BackupDir(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Delete(&self) -> ::windows_core::Result<()>; - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GenerateReportToFile(&self, gpmreporttype: GPMReportType, bstrtargetfilepath: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMBackup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMBackup_Vtbl { pub const fn new, Impl: IGPMBackup_Impl, const OFFSET: isize>() -> IGPMBackup_Vtbl { unsafe extern "system" fn ID, Impl: IGPMBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -425,7 +425,7 @@ impl IGPMBackup_Vtbl { let this = (*this).get_impl(); this.Delete().into() } - unsafe extern "system" fn GenerateReport, Impl: IGPMBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -459,16 +459,16 @@ impl IGPMBackup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMBackupCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMBackupCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMBackupCollection_Vtbl { pub const fn new, Impl: IGPMBackupCollection_Impl, const OFFSET: isize>() -> IGPMBackupCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -482,7 +482,7 @@ impl IGPMBackupCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -515,16 +515,16 @@ impl IGPMBackupCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMBackupDir_Impl: Sized + super::Com::IDispatch_Impl { fn BackupDirectory(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetBackup(&self, bstrid: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchBackups(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMBackupDir {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMBackupDir_Vtbl { pub const fn new, Impl: IGPMBackupDir_Impl, const OFFSET: isize>() -> IGPMBackupDir_Vtbl { unsafe extern "system" fn BackupDirectory, Impl: IGPMBackupDir_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -571,17 +571,17 @@ impl IGPMBackupDir_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMBackupDirEx_Impl: Sized + super::Com::IDispatch_Impl { fn BackupDir(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BackupType(&self) -> ::windows_core::Result; - fn GetBackup(&self, bstrid: &::windows_core::BSTR) -> ::windows_core::Result; - fn SearchBackups(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; + fn GetBackup(&self, bstrid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SearchBackups(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMBackupDirEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMBackupDirEx_Vtbl { pub const fn new, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>() -> IGPMBackupDirEx_Vtbl { unsafe extern "system" fn BackupDir, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrbackupdir: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -606,7 +606,7 @@ impl IGPMBackupDirEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetBackup, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbackup: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetBackup, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbackup: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetBackup(::core::mem::transmute(&bstrid)) { @@ -617,7 +617,7 @@ impl IGPMBackupDirEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SearchBackups, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, pvarbackupcollection: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SearchBackups, Impl: IGPMBackupDirEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, pvarbackupcollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SearchBackups(::windows_core::from_raw_borrowed(&pigpmsearchcriteria)) { @@ -640,16 +640,16 @@ impl IGPMBackupDirEx_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMCSECollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMCSECollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMCSECollection_Vtbl { pub const fn new, Impl: IGPMCSECollection_Impl, const OFFSET: isize>() -> IGPMCSECollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMCSECollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -663,7 +663,7 @@ impl IGPMCSECollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMCSECollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMCSECollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -696,17 +696,17 @@ impl IGPMCSECollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMClientSideExtension_Impl: Sized + super::Com::IDispatch_Impl { fn ID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IsUserEnabled(&self) -> ::windows_core::Result; fn IsComputerEnabled(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMClientSideExtension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMClientSideExtension_Vtbl { pub const fn new, Impl: IGPMClientSideExtension_Impl, const OFFSET: isize>() -> IGPMClientSideExtension_Vtbl { unsafe extern "system" fn ID, Impl: IGPMClientSideExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -765,8 +765,8 @@ impl IGPMClientSideExtension_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMConstants_Impl: Sized + super::Com::IDispatch_Impl { fn PermGPOApply(&self) -> ::windows_core::Result; fn PermGPORead(&self) -> ::windows_core::Result; @@ -829,9 +829,9 @@ pub trait IGPMConstants_Impl: Sized + super::Com::IDispatch_Impl { fn RsopPlanningAssumeUserWQLFilterTrue(&self) -> ::windows_core::Result; fn RsopPlanningAssumeCompWQLFilterTrue(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMConstants {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMConstants_Vtbl { pub const fn new, Impl: IGPMConstants_Impl, const OFFSET: isize>() -> IGPMConstants_Vtbl { unsafe extern "system" fn PermGPOApply, Impl: IGPMConstants_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut GPMPermissionType) -> ::windows_core::HRESULT { @@ -1562,8 +1562,8 @@ impl IGPMConstants_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMConstants2_Impl: Sized + IGPMConstants_Impl { fn BackupTypeGPO(&self) -> ::windows_core::Result; fn BackupTypeStarterGPO(&self) -> ::windows_core::Result; @@ -1581,9 +1581,9 @@ pub trait IGPMConstants2_Impl: Sized + IGPMConstants_Impl { fn ReportLegacy(&self) -> ::windows_core::Result; fn ReportComments(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMConstants2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMConstants2_Vtbl { pub const fn new, Impl: IGPMConstants2_Impl, const OFFSET: isize>() -> IGPMConstants2_Vtbl { unsafe extern "system" fn BackupTypeGPO, Impl: IGPMConstants2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut GPMBackupType) -> ::windows_core::HRESULT { @@ -1774,23 +1774,23 @@ impl IGPMConstants2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMDomain_Impl: Sized + super::Com::IDispatch_Impl { fn DomainController(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Domain(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CreateGPO(&self) -> ::windows_core::Result; fn GetGPO(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchGPOs(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; - fn RestoreGPO(&self, pigpmbackup: ::core::option::Option<&IGPMBackup>, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn RestoreGPO(&self, pigpmbackup: ::core::option::Option<&IGPMBackup>, ldcflags: i32, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GetSOM(&self, bstrpath: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchSOMs(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; fn GetWMIFilter(&self, bstrpath: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchWMIFilters(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMDomain {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMDomain_Vtbl { pub const fn new, Impl: IGPMDomain_Impl, const OFFSET: isize>() -> IGPMDomain_Vtbl { unsafe extern "system" fn DomainController, Impl: IGPMDomain_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1848,7 +1848,7 @@ impl IGPMDomain_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RestoreGPO, Impl: IGPMDomain_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmbackup: *mut ::core::ffi::c_void, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RestoreGPO, Impl: IGPMDomain_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmbackup: *mut ::core::ffi::c_void, ldcflags: i32, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RestoreGPO(::windows_core::from_raw_borrowed(&pigpmbackup), ::core::mem::transmute_copy(&ldcflags), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -1915,19 +1915,19 @@ impl IGPMDomain_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMDomain2_Impl: Sized + IGPMDomain_Impl { fn CreateStarterGPO(&self) -> ::windows_core::Result; fn CreateGPOFromStarterGPO(&self, pgpotemplate: ::core::option::Option<&IGPMStarterGPO>) -> ::windows_core::Result; fn GetStarterGPO(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchStarterGPOs(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; - fn LoadStarterGPO(&self, bstrloadfile: &::windows_core::BSTR, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn RestoreStarterGPO(&self, pigpmtmplbackup: ::core::option::Option<&IGPMStarterGPOBackup>, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn LoadStarterGPO(&self, bstrloadfile: &::windows_core::BSTR, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn RestoreStarterGPO(&self, pigpmtmplbackup: ::core::option::Option<&IGPMStarterGPOBackup>, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMDomain2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMDomain2_Vtbl { pub const fn new, Impl: IGPMDomain2_Impl, const OFFSET: isize>() -> IGPMDomain2_Vtbl { unsafe extern "system" fn CreateStarterGPO, Impl: IGPMDomain2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppnewtemplate: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1974,12 +1974,12 @@ impl IGPMDomain2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LoadStarterGPO, Impl: IGPMDomain2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrloadfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LoadStarterGPO, Impl: IGPMDomain2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrloadfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.LoadStarterGPO(::core::mem::transmute(&bstrloadfile), ::core::mem::transmute_copy(&boverwrite), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() } - unsafe extern "system" fn RestoreStarterGPO, Impl: IGPMDomain2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmtmplbackup: *mut ::core::ffi::c_void, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RestoreStarterGPO, Impl: IGPMDomain2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pigpmtmplbackup: *mut ::core::ffi::c_void, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RestoreStarterGPO(::windows_core::from_raw_borrowed(&pigpmtmplbackup), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -1998,20 +1998,20 @@ impl IGPMDomain2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMDomain3_Impl: Sized + IGPMDomain2_Impl { - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn InfrastructureDC(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetInfrastructureDC(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetInfrastructureFlags(&self, dwflags: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMDomain3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMDomain3_Vtbl { pub const fn new, Impl: IGPMDomain3_Impl, const OFFSET: isize>() -> IGPMDomain3_Vtbl { - unsafe extern "system" fn GenerateReport, Impl: IGPMDomain3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMDomain3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -2049,8 +2049,8 @@ impl IGPMDomain3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMGPO_Impl: Sized + super::Com::IDispatch_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDisplayName(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2072,19 +2072,19 @@ pub trait IGPMGPO_Impl: Sized + super::Com::IDispatch_Impl { fn GetSecurityInfo(&self) -> ::windows_core::Result; fn SetSecurityInfo(&self, psecurityinfo: ::core::option::Option<&IGPMSecurityInfo>) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; - fn Backup(&self, bstrbackupdir: &::windows_core::BSTR, bstrcomment: &::windows_core::BSTR, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn Import(&self, lflags: i32, pigpmbackup: ::core::option::Option<&IGPMBackup>, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn Backup(&self, bstrbackupdir: &::windows_core::BSTR, bstrcomment: &::windows_core::BSTR, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn Import(&self, lflags: i32, pigpmbackup: ::core::option::Option<&IGPMBackup>, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GenerateReportToFile(&self, gpmreporttype: GPMReportType, bstrtargetfilepath: &::windows_core::BSTR) -> ::windows_core::Result; - fn CopyTo(&self, lflags: i32, pigpmdomain: ::core::option::Option<&IGPMDomain>, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn CopyTo(&self, lflags: i32, pigpmdomain: ::core::option::Option<&IGPMDomain>, pvarnewdisplayname: *const ::windows_core::VARIANT, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn SetSecurityDescriptor(&self, lflags: i32, psd: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn GetSecurityDescriptor(&self, lflags: i32) -> ::windows_core::Result; fn IsACLConsistent(&self) -> ::windows_core::Result; fn MakeACLConsistent(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMGPO {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMGPO_Vtbl { pub const fn new, Impl: IGPMGPO_Impl, const OFFSET: isize>() -> IGPMGPO_Vtbl { unsafe extern "system" fn DisplayName, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2271,17 +2271,17 @@ impl IGPMGPO_Vtbl { let this = (*this).get_impl(); this.Delete().into() } - unsafe extern "system" fn Backup, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Backup, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Backup(::core::mem::transmute(&bstrbackupdir), ::core::mem::transmute(&bstrcomment), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() } - unsafe extern "system" fn Import, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pigpmbackup: *mut ::core::ffi::c_void, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Import, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pigpmbackup: *mut ::core::ffi::c_void, pvarmigrationtable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Import(::core::mem::transmute_copy(&lflags), ::windows_core::from_raw_borrowed(&pigpmbackup), ::core::mem::transmute_copy(&pvarmigrationtable), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() } - unsafe extern "system" fn GenerateReport, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -2297,7 +2297,7 @@ impl IGPMGPO_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CopyTo, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pigpmdomain: *mut ::core::ffi::c_void, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyTo, Impl: IGPMGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pigpmdomain: *mut ::core::ffi::c_void, pvarnewdisplayname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarmigrationtable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CopyTo(::core::mem::transmute_copy(&lflags), ::windows_core::from_raw_borrowed(&pigpmdomain), ::core::mem::transmute_copy(&pvarnewdisplayname), ::core::mem::transmute_copy(&pvarmigrationtable), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -2371,15 +2371,15 @@ impl IGPMGPO_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMGPO2_Impl: Sized + IGPMGPO_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMGPO2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMGPO2_Vtbl { pub const fn new, Impl: IGPMGPO2_Impl, const OFFSET: isize>() -> IGPMGPO2_Vtbl { unsafe extern "system" fn Description, Impl: IGPMGPO2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2408,16 +2408,16 @@ impl IGPMGPO2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMGPO3_Impl: Sized + IGPMGPO2_Impl { fn InfrastructureDC(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetInfrastructureDC(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetInfrastructureFlags(&self, dwflags: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMGPO3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMGPO3_Vtbl { pub const fn new, Impl: IGPMGPO3_Impl, const OFFSET: isize>() -> IGPMGPO3_Vtbl { unsafe extern "system" fn InfrastructureDC, Impl: IGPMGPO3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2452,16 +2452,16 @@ impl IGPMGPO3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMGPOCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMGPOCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMGPOCollection_Vtbl { pub const fn new, Impl: IGPMGPOCollection_Impl, const OFFSET: isize>() -> IGPMGPOCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -2475,7 +2475,7 @@ impl IGPMGPOCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -2508,8 +2508,8 @@ impl IGPMGPOCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMGPOLink_Impl: Sized + super::Com::IDispatch_Impl { fn GPOID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GPODomain(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2521,9 +2521,9 @@ pub trait IGPMGPOLink_Impl: Sized + super::Com::IDispatch_Impl { fn SOM(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMGPOLink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMGPOLink_Vtbl { pub const fn new, Impl: IGPMGPOLink_Impl, const OFFSET: isize>() -> IGPMGPOLink_Vtbl { unsafe extern "system" fn GPOID, Impl: IGPMGPOLink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2624,16 +2624,16 @@ impl IGPMGPOLink_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMGPOLinksCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMGPOLinksCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMGPOLinksCollection_Vtbl { pub const fn new, Impl: IGPMGPOLinksCollection_Impl, const OFFSET: isize>() -> IGPMGPOLinksCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMGPOLinksCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -2647,7 +2647,7 @@ impl IGPMGPOLinksCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMGPOLinksCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMGPOLinksCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -2680,17 +2680,17 @@ impl IGPMGPOLinksCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMMapEntry_Impl: Sized + super::Com::IDispatch_Impl { fn Source(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Destination(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DestinationOption(&self) -> ::windows_core::Result; fn EntryType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMMapEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMMapEntry_Vtbl { pub const fn new, Impl: IGPMMapEntry_Impl, const OFFSET: isize>() -> IGPMMapEntry_Vtbl { unsafe extern "system" fn Source, Impl: IGPMMapEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2749,16 +2749,16 @@ impl IGPMMapEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMMapEntryCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMMapEntryCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMMapEntryCollection_Vtbl { pub const fn new, Impl: IGPMMapEntryCollection_Impl, const OFFSET: isize>() -> IGPMMapEntryCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMMapEntryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -2772,7 +2772,7 @@ impl IGPMMapEntryCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMMapEntryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMMapEntryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -2805,21 +2805,21 @@ impl IGPMMapEntryCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMMigrationTable_Impl: Sized + super::Com::IDispatch_Impl { fn Save(&self, bstrmigrationtablepath: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Add(&self, lflags: i32, var: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AddEntry(&self, bstrsource: &::windows_core::BSTR, gpmentrytype: GPMEntryType, pvardestination: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn Add(&self, lflags: i32, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AddEntry(&self, bstrsource: &::windows_core::BSTR, gpmentrytype: GPMEntryType, pvardestination: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn GetEntry(&self, bstrsource: &::windows_core::BSTR) -> ::windows_core::Result; fn DeleteEntry(&self, bstrsource: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn UpdateDestination(&self, bstrsource: &::windows_core::BSTR, pvardestination: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn UpdateDestination(&self, bstrsource: &::windows_core::BSTR, pvardestination: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Validate(&self) -> ::windows_core::Result; fn GetEntries(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMMigrationTable {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMMigrationTable_Vtbl { pub const fn new, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>() -> IGPMMigrationTable_Vtbl { unsafe extern "system" fn Save, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrmigrationtablepath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2827,12 +2827,12 @@ impl IGPMMigrationTable_Vtbl { let this = (*this).get_impl(); this.Save(::core::mem::transmute(&bstrmigrationtablepath)).into() } - unsafe extern "system" fn Add, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, var: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&var)).into() } - unsafe extern "system" fn AddEntry, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, gpmentrytype: GPMEntryType, pvardestination: *const super::Variant::VARIANT, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddEntry, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, gpmentrytype: GPMEntryType, pvardestination: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AddEntry(::core::mem::transmute(&bstrsource), ::core::mem::transmute_copy(&gpmentrytype), ::core::mem::transmute_copy(&pvardestination)) { @@ -2859,7 +2859,7 @@ impl IGPMMigrationTable_Vtbl { let this = (*this).get_impl(); this.DeleteEntry(::core::mem::transmute(&bstrsource)).into() } - unsafe extern "system" fn UpdateDestination, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardestination: *const super::Variant::VARIANT, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn UpdateDestination, Impl: IGPMMigrationTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardestination: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.UpdateDestination(::core::mem::transmute(&bstrsource), ::core::mem::transmute_copy(&pvardestination)) { @@ -2908,8 +2908,8 @@ impl IGPMMigrationTable_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMPermission_Impl: Sized + super::Com::IDispatch_Impl { fn Inherited(&self) -> ::windows_core::Result; fn Inheritable(&self) -> ::windows_core::Result; @@ -2917,9 +2917,9 @@ pub trait IGPMPermission_Impl: Sized + super::Com::IDispatch_Impl { fn Permission(&self) -> ::windows_core::Result; fn Trustee(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMPermission {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMPermission_Vtbl { pub const fn new, Impl: IGPMPermission_Impl, const OFFSET: isize>() -> IGPMPermission_Vtbl { unsafe extern "system" fn Inherited, Impl: IGPMPermission_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2990,8 +2990,8 @@ impl IGPMPermission_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMRSOP_Impl: Sized + super::Com::IDispatch_Impl { fn Mode(&self) -> ::windows_core::Result; fn Namespace(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3011,27 +3011,27 @@ pub trait IGPMRSOP_Impl: Sized + super::Com::IDispatch_Impl { fn PlanningUser(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPlanningUserSOM(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PlanningUserSOM(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn SetPlanningUserWMIFilters(&self, varval: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PlanningUserWMIFilters(&self) -> ::windows_core::Result; - fn SetPlanningUserSecurityGroups(&self, varval: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PlanningUserSecurityGroups(&self) -> ::windows_core::Result; + fn SetPlanningUserWMIFilters(&self, varval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PlanningUserWMIFilters(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPlanningUserSecurityGroups(&self, varval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PlanningUserSecurityGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetPlanningComputer(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PlanningComputer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPlanningComputerSOM(&self, bstrval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn PlanningComputerSOM(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn SetPlanningComputerWMIFilters(&self, varval: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PlanningComputerWMIFilters(&self) -> ::windows_core::Result; - fn SetPlanningComputerSecurityGroups(&self, varval: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PlanningComputerSecurityGroups(&self) -> ::windows_core::Result; - fn LoggingEnumerateUsers(&self) -> ::windows_core::Result; + fn SetPlanningComputerWMIFilters(&self, varval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PlanningComputerWMIFilters(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPlanningComputerSecurityGroups(&self, varval: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PlanningComputerSecurityGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn LoggingEnumerateUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn CreateQueryResults(&self) -> ::windows_core::Result<()>; fn ReleaseQueryResults(&self) -> ::windows_core::Result<()>; - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GenerateReportToFile(&self, gpmreporttype: GPMReportType, bstrtargetfilepath: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMRSOP {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMRSOP_Vtbl { pub const fn new, Impl: IGPMRSOP_Impl, const OFFSET: isize>() -> IGPMRSOP_Vtbl { unsafe extern "system" fn Mode, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut GPMRSOPMode) -> ::windows_core::HRESULT { @@ -3184,12 +3184,12 @@ impl IGPMRSOP_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPlanningUserWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPlanningUserWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPlanningUserWMIFilters(::core::mem::transmute(&varval)).into() } - unsafe extern "system" fn PlanningUserWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlanningUserWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PlanningUserWMIFilters() { @@ -3200,12 +3200,12 @@ impl IGPMRSOP_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPlanningUserSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPlanningUserSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPlanningUserSecurityGroups(::core::mem::transmute(&varval)).into() } - unsafe extern "system" fn PlanningUserSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlanningUserSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PlanningUserSecurityGroups() { @@ -3248,12 +3248,12 @@ impl IGPMRSOP_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPlanningComputerWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPlanningComputerWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPlanningComputerWMIFilters(::core::mem::transmute(&varval)).into() } - unsafe extern "system" fn PlanningComputerWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlanningComputerWMIFilters, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PlanningComputerWMIFilters() { @@ -3264,12 +3264,12 @@ impl IGPMRSOP_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPlanningComputerSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPlanningComputerSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPlanningComputerSecurityGroups(::core::mem::transmute(&varval)).into() } - unsafe extern "system" fn PlanningComputerSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PlanningComputerSecurityGroups, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PlanningComputerSecurityGroups() { @@ -3280,7 +3280,7 @@ impl IGPMRSOP_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LoggingEnumerateUsers, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LoggingEnumerateUsers, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LoggingEnumerateUsers() { @@ -3301,7 +3301,7 @@ impl IGPMRSOP_Vtbl { let this = (*this).get_impl(); this.ReleaseQueryResults().into() } - unsafe extern "system" fn GenerateReport, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMRSOP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -3360,16 +3360,16 @@ impl IGPMRSOP_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMResult_Impl: Sized + super::Com::IDispatch_Impl { fn Status(&self) -> ::windows_core::Result; - fn Result(&self) -> ::windows_core::Result; + fn Result(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn OverallStatus(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMResult_Vtbl { pub const fn new, Impl: IGPMResult_Impl, const OFFSET: isize>() -> IGPMResult_Vtbl { unsafe extern "system" fn Status, Impl: IGPMResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppigpmstatusmsgcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3383,7 +3383,7 @@ impl IGPMResult_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Result, Impl: IGPMResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarresult: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Result, Impl: IGPMResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Result() { @@ -3410,8 +3410,8 @@ impl IGPMResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMSOM_Impl: Sized + super::Com::IDispatch_Impl { fn GPOInheritanceBlocked(&self) -> ::windows_core::Result; fn SetGPOInheritanceBlocked(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -3424,9 +3424,9 @@ pub trait IGPMSOM_Impl: Sized + super::Com::IDispatch_Impl { fn GetSecurityInfo(&self) -> ::windows_core::Result; fn SetSecurityInfo(&self, psecurityinfo: ::core::option::Option<&IGPMSecurityInfo>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMSOM {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMSOM_Vtbl { pub const fn new, Impl: IGPMSOM_Impl, const OFFSET: isize>() -> IGPMSOM_Vtbl { unsafe extern "system" fn GPOInheritanceBlocked, Impl: IGPMSOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3545,16 +3545,16 @@ impl IGPMSOM_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMSOMCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMSOMCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMSOMCollection_Vtbl { pub const fn new, Impl: IGPMSOMCollection_Impl, const OFFSET: isize>() -> IGPMSOMCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMSOMCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -3568,7 +3568,7 @@ impl IGPMSOMCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMSOMCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMSOMCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -3601,17 +3601,17 @@ impl IGPMSOMCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMSearchCriteria_Impl: Sized + super::Com::IDispatch_Impl { - fn Add(&self, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Add(&self, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMSearchCriteria {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMSearchCriteria_Vtbl { pub const fn new, Impl: IGPMSearchCriteria_Impl, const OFFSET: isize>() -> IGPMSearchCriteria_Vtbl { - unsafe extern "system" fn Add, Impl: IGPMSearchCriteria_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IGPMSearchCriteria_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&searchproperty), ::core::mem::transmute_copy(&searchoperation), ::core::mem::transmute(&varvalue)).into() @@ -3622,19 +3622,19 @@ impl IGPMSearchCriteria_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMSecurityInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; fn Add(&self, pperm: ::core::option::Option<&IGPMPermission>) -> ::windows_core::Result<()>; fn Remove(&self, pperm: ::core::option::Option<&IGPMPermission>) -> ::windows_core::Result<()>; fn RemoveTrustee(&self, bstrtrustee: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMSecurityInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMSecurityInfo_Vtbl { pub const fn new, Impl: IGPMSecurityInfo_Impl, const OFFSET: isize>() -> IGPMSecurityInfo_Vtbl { unsafe extern "system" fn Count, Impl: IGPMSecurityInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -3648,7 +3648,7 @@ impl IGPMSecurityInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMSecurityInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMSecurityInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -3699,8 +3699,8 @@ impl IGPMSecurityInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMSitesContainer_Impl: Sized + super::Com::IDispatch_Impl { fn DomainController(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Domain(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3708,9 +3708,9 @@ pub trait IGPMSitesContainer_Impl: Sized + super::Com::IDispatch_Impl { fn GetSite(&self, bstrsitename: &::windows_core::BSTR) -> ::windows_core::Result; fn SearchSites(&self, pigpmsearchcriteria: ::core::option::Option<&IGPMSearchCriteria>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMSitesContainer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMSitesContainer_Vtbl { pub const fn new, Impl: IGPMSitesContainer_Impl, const OFFSET: isize>() -> IGPMSitesContainer_Vtbl { unsafe extern "system" fn DomainController, Impl: IGPMSitesContainer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3781,8 +3781,8 @@ impl IGPMSitesContainer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMStarterGPO_Impl: Sized + super::Com::IDispatch_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDisplayName(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3798,17 +3798,17 @@ pub trait IGPMStarterGPO_Impl: Sized + super::Com::IDispatch_Impl { fn UserVersion(&self) -> ::windows_core::Result; fn StarterGPOVersion(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Delete(&self) -> ::windows_core::Result<()>; - fn Save(&self, bstrsavefile: &::windows_core::BSTR, boverwrite: super::super::Foundation::VARIANT_BOOL, bsaveassystem: super::super::Foundation::VARIANT_BOOL, bstrlanguage: *const super::Variant::VARIANT, bstrauthor: *const super::Variant::VARIANT, bstrproduct: *const super::Variant::VARIANT, bstruniqueid: *const super::Variant::VARIANT, bstrversion: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn Backup(&self, bstrbackupdir: &::windows_core::BSTR, bstrcomment: &::windows_core::BSTR, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn CopyTo(&self, pvarnewdisplayname: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn Save(&self, bstrsavefile: &::windows_core::BSTR, boverwrite: super::super::Foundation::VARIANT_BOOL, bsaveassystem: super::super::Foundation::VARIANT_BOOL, bstrlanguage: *const ::windows_core::VARIANT, bstrauthor: *const ::windows_core::VARIANT, bstrproduct: *const ::windows_core::VARIANT, bstruniqueid: *const ::windows_core::VARIANT, bstrversion: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn Backup(&self, bstrbackupdir: &::windows_core::BSTR, bstrcomment: &::windows_core::BSTR, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn CopyTo(&self, pvarnewdisplayname: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn GenerateReportToFile(&self, gpmreporttype: GPMReportType, bstrtargetfilepath: &::windows_core::BSTR) -> ::windows_core::Result; fn GetSecurityInfo(&self) -> ::windows_core::Result; fn SetSecurityInfo(&self, psecurityinfo: ::core::option::Option<&IGPMSecurityInfo>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMStarterGPO {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMStarterGPO_Vtbl { pub const fn new, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>() -> IGPMStarterGPO_Vtbl { unsafe extern "system" fn DisplayName, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3947,18 +3947,31 @@ impl IGPMStarterGPO_Vtbl { let this = (*this).get_impl(); this.Delete().into() } - unsafe extern "system" fn Save, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsavefile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, bsaveassystem: super::super::Foundation::VARIANT_BOOL, bstrlanguage: *const super::Variant::VARIANT, bstrauthor: *const super::Variant::VARIANT, bstrproduct: *const super::Variant::VARIANT, bstruniqueid: *const super::Variant::VARIANT, bstrversion: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Save, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + bstrsavefile: ::std::mem::MaybeUninit<::windows_core::BSTR>, + boverwrite: super::super::Foundation::VARIANT_BOOL, + bsaveassystem: super::super::Foundation::VARIANT_BOOL, + bstrlanguage: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrauthor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrproduct: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstruniqueid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrversion: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppigpmresult: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Save(::core::mem::transmute(&bstrsavefile), ::core::mem::transmute_copy(&boverwrite), ::core::mem::transmute_copy(&bsaveassystem), ::core::mem::transmute_copy(&bstrlanguage), ::core::mem::transmute_copy(&bstrauthor), ::core::mem::transmute_copy(&bstrproduct), ::core::mem::transmute_copy(&bstruniqueid), ::core::mem::transmute_copy(&bstrversion), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)) .into() } - unsafe extern "system" fn Backup, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Backup, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Backup(::core::mem::transmute(&bstrbackupdir), ::core::mem::transmute(&bstrcomment), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() } - unsafe extern "system" fn CopyTo, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarnewdisplayname: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyTo, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarnewdisplayname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CopyTo(::core::mem::transmute_copy(&pvarnewdisplayname), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel)) { @@ -3969,7 +3982,7 @@ impl IGPMStarterGPO_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GenerateReport, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMStarterGPO_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel)) { @@ -4036,8 +4049,8 @@ impl IGPMStarterGPO_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMStarterGPOBackup_Impl: Sized + super::Com::IDispatch_Impl { fn BackupDir(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Comment(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4048,12 +4061,12 @@ pub trait IGPMStarterGPOBackup_Impl: Sized + super::Com::IDispatch_Impl { fn Timestamp(&self) -> ::windows_core::Result; fn Type(&self) -> ::windows_core::Result; fn Delete(&self) -> ::windows_core::Result<()>; - fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GenerateReportToFile(&self, gpmreporttype: GPMReportType, bstrtargetfilepath: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMStarterGPOBackup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMStarterGPOBackup_Vtbl { pub const fn new, Impl: IGPMStarterGPOBackup_Impl, const OFFSET: isize>() -> IGPMStarterGPOBackup_Vtbl { unsafe extern "system" fn BackupDir, Impl: IGPMStarterGPOBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrbackupdir: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4149,7 +4162,7 @@ impl IGPMStarterGPOBackup_Vtbl { let this = (*this).get_impl(); this.Delete().into() } - unsafe extern "system" fn GenerateReport, Impl: IGPMStarterGPOBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GenerateReport, Impl: IGPMStarterGPOBackup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GenerateReport(::core::mem::transmute_copy(&gpmreporttype), ::core::mem::transmute_copy(&pvargpmprogress), ::core::mem::transmute_copy(&pvargpmcancel), ::core::mem::transmute_copy(&ppigpmresult)).into() @@ -4184,16 +4197,16 @@ impl IGPMStarterGPOBackup_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMStarterGPOBackupCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMStarterGPOBackupCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMStarterGPOBackupCollection_Vtbl { pub const fn new, Impl: IGPMStarterGPOBackupCollection_Impl, const OFFSET: isize>() -> IGPMStarterGPOBackupCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMStarterGPOBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -4207,7 +4220,7 @@ impl IGPMStarterGPOBackupCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMStarterGPOBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMStarterGPOBackupCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -4240,16 +4253,16 @@ impl IGPMStarterGPOBackupCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMStarterGPOCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMStarterGPOCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMStarterGPOCollection_Vtbl { pub const fn new, Impl: IGPMStarterGPOCollection_Impl, const OFFSET: isize>() -> IGPMStarterGPOCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMStarterGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -4263,7 +4276,7 @@ impl IGPMStarterGPOCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMStarterGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMStarterGPOCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -4296,8 +4309,8 @@ impl IGPMStarterGPOCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMStatusMessage_Impl: Sized + super::Com::IDispatch_Impl { fn ObjectPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ErrorCode(&self) -> ::windows_core::Result<()>; @@ -4306,9 +4319,9 @@ pub trait IGPMStatusMessage_Impl: Sized + super::Com::IDispatch_Impl { fn OperationCode(&self) -> ::windows_core::Result<()>; fn Message(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMStatusMessage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMStatusMessage_Vtbl { pub const fn new, Impl: IGPMStatusMessage_Impl, const OFFSET: isize>() -> IGPMStatusMessage_Vtbl { unsafe extern "system" fn ObjectPath, Impl: IGPMStatusMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4379,16 +4392,16 @@ impl IGPMStatusMessage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMStatusMsgCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMStatusMsgCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMStatusMsgCollection_Vtbl { pub const fn new, Impl: IGPMStatusMsgCollection_Impl, const OFFSET: isize>() -> IGPMStatusMsgCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMStatusMsgCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -4402,7 +4415,7 @@ impl IGPMStatusMsgCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMStatusMsgCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMStatusMsgCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { @@ -4435,8 +4448,8 @@ impl IGPMStatusMsgCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMTrustee_Impl: Sized + super::Com::IDispatch_Impl { fn TrusteeSid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TrusteeName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4444,9 +4457,9 @@ pub trait IGPMTrustee_Impl: Sized + super::Com::IDispatch_Impl { fn TrusteeDSPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TrusteeType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMTrustee {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMTrustee_Vtbl { pub const fn new, Impl: IGPMTrustee_Impl, const OFFSET: isize>() -> IGPMTrustee_Vtbl { unsafe extern "system" fn TrusteeSid, Impl: IGPMTrustee_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4517,21 +4530,21 @@ impl IGPMTrustee_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IGPMWMIFilter_Impl: Sized + super::Com::IDispatch_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetName(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetQueryList(&self) -> ::windows_core::Result; + fn GetQueryList(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetSecurityInfo(&self) -> ::windows_core::Result; fn SetSecurityInfo(&self, psecurityinfo: ::core::option::Option<&IGPMSecurityInfo>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IGPMWMIFilter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IGPMWMIFilter_Vtbl { pub const fn new, Impl: IGPMWMIFilter_Impl, const OFFSET: isize>() -> IGPMWMIFilter_Vtbl { unsafe extern "system" fn Path, Impl: IGPMWMIFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4577,7 +4590,7 @@ impl IGPMWMIFilter_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetQueryList, Impl: IGPMWMIFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pqrylist: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetQueryList, Impl: IGPMWMIFilter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pqrylist: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetQueryList() { @@ -4620,16 +4633,16 @@ impl IGPMWMIFilter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IGPMWMIFilterCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, lindex: i32) -> ::windows_core::Result; + fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IGPMWMIFilterCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IGPMWMIFilterCollection_Vtbl { pub const fn new, Impl: IGPMWMIFilterCollection_Impl, const OFFSET: isize>() -> IGPMWMIFilterCollection_Vtbl { unsafe extern "system" fn Count, Impl: IGPMWMIFilterCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT { @@ -4643,7 +4656,7 @@ impl IGPMWMIFilterCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IGPMWMIFilterCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IGPMWMIFilterCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&lindex)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/mod.rs b/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/mod.rs index f14a369444..ecfd26aba5 100644 --- a/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/GroupPolicy/mod.rs @@ -652,13 +652,13 @@ pub struct IGPMAsyncCancel_Vtbl { ::windows_core::imp::interface_hierarchy!(IGPMAsyncProgress, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IGPMAsyncProgress { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Status(&self, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const super::Variant::VARIANT, ppigpmstatusmsgcollection: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Status(&self, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const ::windows_core::VARIANT, ppigpmstatusmsgcollection: P0) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Status)(::windows_core::Interface::as_raw(self), lprogressnumerator, lprogressdenominator, hrstatus, presult, ppigpmstatusmsgcollection.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).Status)(::windows_core::Interface::as_raw(self), lprogressnumerator, lprogressdenominator, hrstatus, ::core::mem::transmute(presult), ppigpmstatusmsgcollection.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -666,9 +666,9 @@ impl IGPMAsyncProgress { #[doc(hidden)] pub struct IGPMAsyncProgress_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const super::Variant::VARIANT, ppigpmstatusmsgcollection: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lprogressnumerator: i32, lprogressdenominator: i32, hrstatus: ::windows_core::HRESULT, presult: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmstatusmsgcollection: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Status: usize, } #[cfg(feature = "Win32_System_Com")] @@ -713,10 +713,10 @@ impl IGPMBackup { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -741,9 +741,9 @@ pub struct IGPMBackup_Vtbl { pub Comment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BackupDir: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, #[cfg(feature = "Win32_System_Com")] pub GenerateReportToFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, bstrtargetfilepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -765,9 +765,7 @@ impl IGPMBackupCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -784,10 +782,7 @@ impl IGPMBackupCollection { pub struct IGPMBackupCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmbackup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -861,18 +856,16 @@ impl IGPMBackupDirEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BackupType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetBackup(&self, bstrid: P0) -> ::windows_core::Result + pub unsafe fn GetBackup(&self, bstrid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetBackup)(::windows_core::Interface::as_raw(self), bstrid.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SearchBackups(&self, pigpmsearchcriteria: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn SearchBackups(&self, pigpmsearchcriteria: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -887,13 +880,10 @@ pub struct IGPMBackupDirEx_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub BackupDir: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrbackupdir: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BackupType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pgpmbackuptype: *mut GPMBackupType) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetBackup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbackup: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetBackup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SearchBackups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, pvarbackupcollection: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub GetBackup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbackup: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub SearchBackups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, pvarbackupcollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] SearchBackups: usize, } #[cfg(feature = "Win32_System_Com")] @@ -911,9 +901,7 @@ impl IGPMCSECollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -930,10 +918,7 @@ impl IGPMCSECollection { pub struct IGPMCSECollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmcses: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -1689,13 +1674,13 @@ impl IGPMDomain { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SearchGPOs)(::windows_core::Interface::as_raw(self), pigpmsearchcriteria.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1753,9 +1738,9 @@ pub struct IGPMDomain_Vtbl { pub SearchGPOs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, ppigpmgpocollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SearchGPOs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RestoreGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmbackup: *mut ::core::ffi::c_void, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RestoreGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmbackup: *mut ::core::ffi::c_void, ldcflags: i32, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RestoreGPO: usize, #[cfg(feature = "Win32_System_Com")] pub GetSOM: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppsom: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1817,13 +1802,13 @@ impl IGPMDomain2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SearchGPOs)(::windows_core::Interface::as_raw(self), pigpmsearchcriteria.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1894,22 +1879,22 @@ impl IGPMDomain2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SearchStarterGPOs)(::windows_core::Interface::as_raw(self), pigpmsearchcriteria.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LoadStarterGPO(&self, bstrloadfile: P0, boverwrite: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LoadStarterGPO(&self, bstrloadfile: P0, boverwrite: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).LoadStarterGPO)(::windows_core::Interface::as_raw(self), bstrloadfile.into_param().abi(), boverwrite.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).LoadStarterGPO)(::windows_core::Interface::as_raw(self), bstrloadfile.into_param().abi(), boverwrite.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestoreStarterGPO(&self, pigpmtmplbackup: P0, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestoreStarterGPO(&self, pigpmtmplbackup: P0, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).RestoreStarterGPO)(::windows_core::Interface::as_raw(self), pigpmtmplbackup.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).RestoreStarterGPO)(::windows_core::Interface::as_raw(self), pigpmtmplbackup.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1933,13 +1918,13 @@ pub struct IGPMDomain2_Vtbl { pub SearchStarterGPOs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmsearchcriteria: *mut ::core::ffi::c_void, ppigpmtemplatecollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SearchStarterGPOs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LoadStarterGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrloadfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LoadStarterGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrloadfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LoadStarterGPO: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RestoreStarterGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmtmplbackup: *mut ::core::ffi::c_void, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RestoreStarterGPO: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pigpmtmplbackup: *mut ::core::ffi::c_void, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RestoreStarterGPO: usize, } #[cfg(feature = "Win32_System_Com")] @@ -1985,13 +1970,13 @@ impl IGPMDomain3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.SearchGPOs)(::windows_core::Interface::as_raw(self), pigpmsearchcriteria.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestoreGPO(&self, pigpmbackup: P0, ldcflags: i32, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.base__.RestoreGPO)(::windows_core::Interface::as_raw(self), pigpmbackup.into_param().abi(), ldcflags, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2062,27 +2047,27 @@ impl IGPMDomain3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.SearchStarterGPOs)(::windows_core::Interface::as_raw(self), pigpmsearchcriteria.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LoadStarterGPO(&self, bstrloadfile: P0, boverwrite: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LoadStarterGPO(&self, bstrloadfile: P0, boverwrite: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.LoadStarterGPO)(::windows_core::Interface::as_raw(self), bstrloadfile.into_param().abi(), boverwrite.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.LoadStarterGPO)(::windows_core::Interface::as_raw(self), bstrloadfile.into_param().abi(), boverwrite.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RestoreStarterGPO(&self, pigpmtmplbackup: P0, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RestoreStarterGPO(&self, pigpmtmplbackup: P0, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.RestoreStarterGPO)(::windows_core::Interface::as_raw(self), pigpmtmplbackup.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.RestoreStarterGPO)(::windows_core::Interface::as_raw(self), pigpmtmplbackup.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } pub unsafe fn InfrastructureDC(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2103,9 +2088,9 @@ impl IGPMDomain3 { #[doc(hidden)] pub struct IGPMDomain3_Vtbl { pub base__: IGPMDomain2_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, pub InfrastructureDC: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetInfrastructureDC: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -2219,27 +2204,27 @@ impl IGPMGPO { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2250,13 +2235,13 @@ impl IGPMGPO { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GenerateReportToFile)(::windows_core::Interface::as_raw(self), gpmreporttype, bstrtargetfilepath.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const ::windows_core::VARIANT, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), pvarnewdisplayname, pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), ::core::mem::transmute(pvarnewdisplayname), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2317,25 +2302,25 @@ pub struct IGPMGPO_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] SetSecurityInfo: usize, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Backup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Backup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Backup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pigpmbackup: *mut ::core::ffi::c_void, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pigpmbackup: *mut ::core::ffi::c_void, pvarmigrationtable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Import: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, #[cfg(feature = "Win32_System_Com")] pub GenerateReportToFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, bstrtargetfilepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GenerateReportToFile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyTo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pigpmdomain: *mut ::core::ffi::c_void, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CopyTo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pigpmdomain: *mut ::core::ffi::c_void, pvarnewdisplayname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarmigrationtable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CopyTo: usize, #[cfg(feature = "Win32_System_Com")] pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, psd: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2456,27 +2441,27 @@ impl IGPMGPO2 { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2487,13 +2472,13 @@ impl IGPMGPO2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GenerateReportToFile)(::windows_core::Interface::as_raw(self), gpmreporttype, bstrtargetfilepath.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const ::windows_core::VARIANT, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), pvarnewdisplayname, pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), ::core::mem::transmute(pvarnewdisplayname), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2643,27 +2628,27 @@ impl IGPMGPO3 { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.base__.Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Import(&self, lflags: i32, pigpmbackup: P0, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.base__.Import)(::windows_core::Interface::as_raw(self), lflags, pigpmbackup.into_param().abi(), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2674,13 +2659,13 @@ impl IGPMGPO3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GenerateReportToFile)(::windows_core::Interface::as_raw(self), gpmreporttype, bstrtargetfilepath.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const super::Variant::VARIANT, pvarmigrationtable: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CopyTo(&self, lflags: i32, pigpmdomain: P0, pvarnewdisplayname: *const ::windows_core::VARIANT, pvarmigrationtable: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), pvarnewdisplayname, pvarmigrationtable, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).base__.base__.CopyTo)(::windows_core::Interface::as_raw(self), lflags, pigpmdomain.into_param().abi(), ::core::mem::transmute(pvarnewdisplayname), ::core::mem::transmute(pvarmigrationtable), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2751,9 +2736,7 @@ impl IGPMGPOCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -2770,10 +2753,7 @@ impl IGPMGPOCollection { pub struct IGPMGPOCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmgpos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -2865,9 +2845,7 @@ impl IGPMGPOLinksCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -2884,10 +2862,7 @@ impl IGPMGPOLinksCollection { pub struct IGPMGPOLinksCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmlinks: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -2946,9 +2921,7 @@ impl IGPMMapEntryCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -2965,10 +2938,7 @@ impl IGPMMapEntryCollection { pub struct IGPMMapEntryCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -2991,19 +2961,20 @@ impl IGPMMigrationTable { { (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), bstrmigrationtablepath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, lflags: i32, var: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(var)).ok() + pub unsafe fn Add(&self, lflags: i32, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), lflags, var.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddEntry(&self, bstrsource: P0, gpmentrytype: GPMEntryType, pvardestination: *const super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn AddEntry(&self, bstrsource: P0, gpmentrytype: GPMEntryType, pvardestination: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).AddEntry)(::windows_core::Interface::as_raw(self), bstrsource.into_param().abi(), gpmentrytype, pvardestination, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).AddEntry)(::windows_core::Interface::as_raw(self), bstrsource.into_param().abi(), gpmentrytype, ::core::mem::transmute(pvardestination), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3020,14 +2991,14 @@ impl IGPMMigrationTable { { (::windows_core::Interface::vtable(self).DeleteEntry)(::windows_core::Interface::as_raw(self), bstrsource.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UpdateDestination(&self, bstrsource: P0, pvardestination: *const super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn UpdateDestination(&self, bstrsource: P0, pvardestination: *const ::windows_core::VARIANT) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).UpdateDestination)(::windows_core::Interface::as_raw(self), bstrsource.into_param().abi(), pvardestination, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).UpdateDestination)(::windows_core::Interface::as_raw(self), bstrsource.into_param().abi(), ::core::mem::transmute(pvardestination), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3048,22 +3019,19 @@ impl IGPMMigrationTable { pub struct IGPMMigrationTable_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmigrationtablepath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, var: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, gpmentrytype: GPMEntryType, pvardestination: *const super::Variant::VARIANT, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub AddEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, gpmentrytype: GPMEntryType, pvardestination: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] AddEntry: usize, #[cfg(feature = "Win32_System_Com")] pub GetEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetEntry: usize, pub DeleteEntry: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UpdateDestination: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardestination: *const super::Variant::VARIANT, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub UpdateDestination: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsource: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardestination: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppentry: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] UpdateDestination: usize, #[cfg(feature = "Win32_System_Com")] pub Validate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3215,25 +3183,23 @@ impl IGPMRSOP { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningUserSOM)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPlanningUserWMIFilters(&self, varval: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPlanningUserWMIFilters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varval)).ok() + pub unsafe fn SetPlanningUserWMIFilters(&self, varval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPlanningUserWMIFilters)(::windows_core::Interface::as_raw(self), varval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PlanningUserWMIFilters(&self) -> ::windows_core::Result { + pub unsafe fn PlanningUserWMIFilters(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningUserWMIFilters)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPlanningUserSecurityGroups(&self, varval: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPlanningUserSecurityGroups)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varval)).ok() + pub unsafe fn SetPlanningUserSecurityGroups(&self, varval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPlanningUserSecurityGroups)(::windows_core::Interface::as_raw(self), varval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PlanningUserSecurityGroups(&self) -> ::windows_core::Result { + pub unsafe fn PlanningUserSecurityGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningUserSecurityGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3257,31 +3223,27 @@ impl IGPMRSOP { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningComputerSOM)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPlanningComputerWMIFilters(&self, varval: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPlanningComputerWMIFilters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varval)).ok() + pub unsafe fn SetPlanningComputerWMIFilters(&self, varval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPlanningComputerWMIFilters)(::windows_core::Interface::as_raw(self), varval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PlanningComputerWMIFilters(&self) -> ::windows_core::Result { + pub unsafe fn PlanningComputerWMIFilters(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningComputerWMIFilters)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPlanningComputerSecurityGroups(&self, varval: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPlanningComputerSecurityGroups)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varval)).ok() + pub unsafe fn SetPlanningComputerSecurityGroups(&self, varval: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPlanningComputerSecurityGroups)(::windows_core::Interface::as_raw(self), varval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PlanningComputerSecurityGroups(&self) -> ::windows_core::Result { + pub unsafe fn PlanningComputerSecurityGroups(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PlanningComputerSecurityGroups)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LoggingEnumerateUsers(&self) -> ::windows_core::Result { + pub unsafe fn LoggingEnumerateUsers(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LoggingEnumerateUsers)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3291,10 +3253,10 @@ impl IGPMRSOP { pub unsafe fn ReleaseQueryResults(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ReleaseQueryResults)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3329,51 +3291,24 @@ pub struct IGPMRSOP_Vtbl { pub PlanningUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetPlanningUserSOM: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PlanningUserSOM: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPlanningUserWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPlanningUserWMIFilters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PlanningUserWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PlanningUserWMIFilters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPlanningUserSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPlanningUserSecurityGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PlanningUserSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PlanningUserSecurityGroups: usize, + pub SetPlanningUserWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PlanningUserWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPlanningUserSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PlanningUserSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetPlanningComputer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PlanningComputer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetPlanningComputerSOM: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub PlanningComputerSOM: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPlanningComputerWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPlanningComputerWMIFilters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PlanningComputerWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PlanningComputerWMIFilters: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPlanningComputerSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPlanningComputerSecurityGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PlanningComputerSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PlanningComputerSecurityGroups: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LoggingEnumerateUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LoggingEnumerateUsers: usize, + pub SetPlanningComputerWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PlanningComputerWMIFilters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPlanningComputerSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PlanningComputerSecurityGroups: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub LoggingEnumerateUsers: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub CreateQueryResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ReleaseQueryResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, #[cfg(feature = "Win32_System_Com")] pub GenerateReportToFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, bstrtargetfilepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3397,9 +3332,7 @@ impl IGPMResult { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Status)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Result(&self) -> ::windows_core::Result { + pub unsafe fn Result(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Result)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3416,10 +3349,7 @@ pub struct IGPMResult_Vtbl { pub Status: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmstatusmsgcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Status: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Result: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarresult: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Result: usize, + pub Result: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub OverallStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -3537,9 +3467,7 @@ impl IGPMSOMCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -3556,10 +3484,7 @@ impl IGPMSOMCollection { pub struct IGPMSOMCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmsom: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -3576,10 +3501,11 @@ pub struct IGPMSOMCollection_Vtbl { ::windows_core::imp::interface_hierarchy!(IGPMSearchCriteria, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IGPMSearchCriteria { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), searchproperty, searchoperation, ::core::mem::transmute(varvalue)).ok() + pub unsafe fn Add(&self, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), searchproperty, searchoperation, varvalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3587,10 +3513,7 @@ impl IGPMSearchCriteria { #[doc(hidden)] pub struct IGPMSearchCriteria_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, searchproperty: GPMSearchProperty, searchoperation: GPMSearchOperation, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3607,9 +3530,7 @@ impl IGPMSecurityInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -3648,10 +3569,7 @@ impl IGPMSecurityInfo { pub struct IGPMSecurityInfo_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -3795,36 +3713,36 @@ impl IGPMStarterGPO { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, bstrsavefile: P0, boverwrite: P1, bsaveassystem: P2, bstrlanguage: *const super::Variant::VARIANT, bstrauthor: *const super::Variant::VARIANT, bstrproduct: *const super::Variant::VARIANT, bstruniqueid: *const super::Variant::VARIANT, bstrversion: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Save(&self, bstrsavefile: P0, boverwrite: P1, bsaveassystem: P2, bstrlanguage: *const ::windows_core::VARIANT, bstrauthor: *const ::windows_core::VARIANT, bstrproduct: *const ::windows_core::VARIANT, bstruniqueid: *const ::windows_core::VARIANT, bstrversion: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), bstrsavefile.into_param().abi(), boverwrite.into_param().abi(), bsaveassystem.into_param().abi(), bstrlanguage, bstrauthor, bstrproduct, bstruniqueid, bstrversion, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), bstrsavefile.into_param().abi(), boverwrite.into_param().abi(), bsaveassystem.into_param().abi(), ::core::mem::transmute(bstrlanguage), ::core::mem::transmute(bstrauthor), ::core::mem::transmute(bstrproduct), ::core::mem::transmute(bstruniqueid), ::core::mem::transmute(bstrversion), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Backup(&self, bstrbackupdir: P0, bstrcomment: P1, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + (::windows_core::Interface::vtable(self).Backup)(::windows_core::Interface::as_raw(self), bstrbackupdir.into_param().abi(), bstrcomment.into_param().abi(), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyTo(&self, pvarnewdisplayname: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CopyTo(&self, pvarnewdisplayname: *const ::windows_core::VARIANT, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CopyTo)(::windows_core::Interface::as_raw(self), pvarnewdisplayname, pvargpmprogress, pvargpmcancel, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CopyTo)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarnewdisplayname), ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3869,21 +3787,34 @@ pub struct IGPMStarterGPO_Vtbl { pub UserVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut u16) -> ::windows_core::HRESULT, pub StarterGPOVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsavefile: ::std::mem::MaybeUninit<::windows_core::BSTR>, boverwrite: super::super::Foundation::VARIANT_BOOL, bsaveassystem: super::super::Foundation::VARIANT_BOOL, bstrlanguage: *const super::Variant::VARIANT, bstrauthor: *const super::Variant::VARIANT, bstrproduct: *const super::Variant::VARIANT, bstruniqueid: *const super::Variant::VARIANT, bstrversion: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Save: unsafe extern "system" fn( + this: *mut ::core::ffi::c_void, + bstrsavefile: ::std::mem::MaybeUninit<::windows_core::BSTR>, + boverwrite: super::super::Foundation::VARIANT_BOOL, + bsaveassystem: super::super::Foundation::VARIANT_BOOL, + bstrlanguage: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrauthor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrproduct: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstruniqueid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + bstrversion: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppigpmresult: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Save: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Backup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Backup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrbackupdir: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrcomment: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Backup: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyTo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarnewdisplayname: *const super::Variant::VARIANT, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CopyTo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarnewdisplayname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CopyTo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *const super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, #[cfg(feature = "Win32_System_Com")] pub GenerateReportToFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, bstrtargetfilepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3944,10 +3875,10 @@ impl IGPMStarterGPOBackup { pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, pvargpmprogress, pvargpmcancel, ::core::mem::transmute(ppigpmresult)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GenerateReport(&self, gpmreporttype: GPMReportType, pvargpmprogress: *const ::windows_core::VARIANT, pvargpmcancel: *mut ::windows_core::VARIANT, ppigpmresult: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GenerateReport)(::windows_core::Interface::as_raw(self), gpmreporttype, ::core::mem::transmute(pvargpmprogress), ::core::mem::transmute(pvargpmcancel), ::core::mem::transmute(ppigpmresult)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3973,9 +3904,9 @@ pub struct IGPMStarterGPOBackup_Vtbl { pub Timestamp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptimestamp: *mut f64) -> ::windows_core::HRESULT, pub Type: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptype: *mut GPMStarterGPOType) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const super::Variant::VARIANT, pvargpmcancel: *mut super::Variant::VARIANT, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GenerateReport: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, pvargpmprogress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvargpmcancel: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GenerateReport: usize, #[cfg(feature = "Win32_System_Com")] pub GenerateReportToFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, gpmreporttype: GPMReportType, bstrtargetfilepath: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppigpmresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3997,9 +3928,7 @@ impl IGPMStarterGPOBackupCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -4016,10 +3945,7 @@ impl IGPMStarterGPOBackupCollection { pub struct IGPMStarterGPOBackupCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmtmplbackup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -4040,9 +3966,7 @@ impl IGPMStarterGPOCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -4059,10 +3983,7 @@ impl IGPMStarterGPOCollection { pub struct IGPMStarterGPOCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppigpmtemplates: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -4129,9 +4050,7 @@ impl IGPMStatusMsgCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -4148,10 +4067,7 @@ impl IGPMStatusMsgCollection { pub struct IGPMStatusMsgCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -4235,9 +4151,7 @@ impl IGPMWMIFilter { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Description)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetQueryList(&self) -> ::windows_core::Result { + pub unsafe fn GetQueryList(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetQueryList)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4266,10 +4180,7 @@ pub struct IGPMWMIFilter_Vtbl { pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetQueryList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqrylist: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetQueryList: usize, + pub GetQueryList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqrylist: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetSecurityInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsecurityinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4294,9 +4205,7 @@ impl IGPMWMIFilterCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, lindex: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), lindex, &mut result__).from_abi(result__) } @@ -4313,10 +4222,7 @@ impl IGPMWMIFilterCollection { pub struct IGPMWMIFilterCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lindex: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] diff --git a/crates/libs/windows/src/Windows/Win32/System/Js/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Js/mod.rs index 74fa960f1d..6830fbaddb 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Js/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Js/mod.rs @@ -476,19 +476,15 @@ pub unsafe fn JsStringToPointer(value: *const ::core::ffi::c_void, stringvalue: ::windows_targets::link!("chakra.dll" "system" fn JsStringToPointer(value : *const ::core::ffi::c_void, stringvalue : *mut *mut u16, stringlength : *mut usize) -> JsErrorCode); JsStringToPointer(value, stringvalue, stringlength) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn JsValueToVariant(object: *const ::core::ffi::c_void, variant: *mut super::Variant::VARIANT) -> JsErrorCode { - ::windows_targets::link!("chakra.dll" "system" fn JsValueToVariant(object : *const ::core::ffi::c_void, variant : *mut super::Variant:: VARIANT) -> JsErrorCode); - JsValueToVariant(object, variant) +pub unsafe fn JsValueToVariant(object: *const ::core::ffi::c_void, variant: *mut ::windows_core::VARIANT) -> JsErrorCode { + ::windows_targets::link!("chakra.dll" "system" fn JsValueToVariant(object : *const ::core::ffi::c_void, variant : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> JsErrorCode); + JsValueToVariant(object, ::core::mem::transmute(variant)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn JsVariantToValue(variant: *const super::Variant::VARIANT, value: *mut *mut ::core::ffi::c_void) -> JsErrorCode { - ::windows_targets::link!("chakra.dll" "system" fn JsVariantToValue(variant : *const super::Variant:: VARIANT, value : *mut *mut ::core::ffi::c_void) -> JsErrorCode); - JsVariantToValue(variant, value) +pub unsafe fn JsVariantToValue(variant: *const ::windows_core::VARIANT, value: *mut *mut ::core::ffi::c_void) -> JsErrorCode { + ::windows_targets::link!("chakra.dll" "system" fn JsVariantToValue(variant : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, value : *mut *mut ::core::ffi::c_void) -> JsErrorCode); + JsVariantToValue(::core::mem::transmute(variant), value) } pub const JS_SOURCE_CONTEXT_NONE: u64 = 18446744073709551615u64; pub const JsArray: JsValueType = JsValueType(8i32); diff --git a/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/impl.rs b/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/impl.rs index d724c5d6c1..0c098be57e 100644 --- a/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQApplication_Impl: Sized + super::Com::IDispatch_Impl { fn MachineIdOfMachineName(&self, machinename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQApplication {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQApplication_Vtbl { pub const fn new, Impl: IMSMQApplication_Impl, const OFFSET: isize>() -> IMSMQApplication_Vtbl { unsafe extern "system" fn MachineIdOfMachineName, Impl: IMSMQApplication_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, machinename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrguid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -25,10 +25,10 @@ impl IMSMQApplication_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQApplication2_Impl: Sized + IMSMQApplication_Impl { - fn RegisterCertificate(&self, flags: *const super::Variant::VARIANT, externalcertificate: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RegisterCertificate(&self, flags: *const ::windows_core::VARIANT, externalcertificate: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MachineNameOfMachineId(&self, bstrguid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn MSMQVersionMajor(&self) -> ::windows_core::Result; fn MSMQVersionMinor(&self) -> ::windows_core::Result; @@ -36,12 +36,12 @@ pub trait IMSMQApplication2_Impl: Sized + IMSMQApplication_Impl { fn IsDsEnabled(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQApplication2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQApplication2_Vtbl { pub const fn new, Impl: IMSMQApplication2_Impl, const OFFSET: isize>() -> IMSMQApplication2_Vtbl { - unsafe extern "system" fn RegisterCertificate, Impl: IMSMQApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: *const super::Variant::VARIANT, externalcertificate: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterCertificate, Impl: IMSMQApplication2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, externalcertificate: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RegisterCertificate(::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&externalcertificate)).into() @@ -127,26 +127,26 @@ impl IMSMQApplication2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQApplication3_Impl: Sized + IMSMQApplication2_Impl { - fn ActiveQueues(&self) -> ::windows_core::Result; - fn PrivateQueues(&self) -> ::windows_core::Result; + fn ActiveQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PrivateQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DirectoryServiceServer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IsConnected(&self) -> ::windows_core::Result; - fn BytesInAllQueues(&self) -> ::windows_core::Result; + fn BytesInAllQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetMachine(&self, bstrmachine: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Machine(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Connect(&self) -> ::windows_core::Result<()>; fn Disconnect(&self) -> ::windows_core::Result<()>; fn Tidy(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQApplication3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQApplication3_Vtbl { pub const fn new, Impl: IMSMQApplication3_Impl, const OFFSET: isize>() -> IMSMQApplication3_Vtbl { - unsafe extern "system" fn ActiveQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvactivequeues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ActiveQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvactivequeues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ActiveQueues() { @@ -157,7 +157,7 @@ impl IMSMQApplication3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PrivateQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvprivatequeues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PrivateQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvprivatequeues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PrivateQueues() { @@ -190,7 +190,7 @@ impl IMSMQApplication3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BytesInAllQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinallqueues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BytesInAllQueues, Impl: IMSMQApplication3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinallqueues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BytesInAllQueues() { @@ -250,19 +250,19 @@ impl IMSMQApplication3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQCollection_Impl: Sized + super::Com::IDispatch_Impl { - fn Item(&self, index: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, index: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQCollection_Vtbl { pub const fn new, Impl: IMSMQCollection_Impl, const OFFSET: isize>() -> IMSMQCollection_Vtbl { - unsafe extern "system" fn Item, Impl: IMSMQCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: *const super::Variant::VARIANT, pvarret: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IMSMQCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarret: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute_copy(&index)) { @@ -306,14 +306,14 @@ impl IMSMQCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQCoordinatedTransactionDispenser_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQCoordinatedTransactionDispenser {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQCoordinatedTransactionDispenser_Vtbl { pub const fn new, Impl: IMSMQCoordinatedTransactionDispenser_Impl, const OFFSET: isize>() -> IMSMQCoordinatedTransactionDispenser_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQCoordinatedTransactionDispenser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -333,15 +333,15 @@ impl IMSMQCoordinatedTransactionDispenser_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQCoordinatedTransactionDispenser2_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQCoordinatedTransactionDispenser2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQCoordinatedTransactionDispenser2_Vtbl { pub const fn new, Impl: IMSMQCoordinatedTransactionDispenser2_Impl, const OFFSET: isize>() -> IMSMQCoordinatedTransactionDispenser2_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQCoordinatedTransactionDispenser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -376,15 +376,15 @@ impl IMSMQCoordinatedTransactionDispenser2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQCoordinatedTransactionDispenser3_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQCoordinatedTransactionDispenser3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQCoordinatedTransactionDispenser3_Vtbl { pub const fn new, Impl: IMSMQCoordinatedTransactionDispenser3_Impl, const OFFSET: isize>() -> IMSMQCoordinatedTransactionDispenser3_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQCoordinatedTransactionDispenser3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -419,8 +419,8 @@ impl IMSMQCoordinatedTransactionDispenser3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQDestination_Impl: Sized + super::Com::IDispatch_Impl { fn Open(&self) -> ::windows_core::Result<()>; fn Close(&self) -> ::windows_core::Result<()>; @@ -437,9 +437,9 @@ pub trait IMSMQDestination_Impl: Sized + super::Com::IDispatch_Impl { fn putref_Destinations(&self, pdestinations: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQDestination {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQDestination_Vtbl { pub const fn new, Impl: IMSMQDestination_Impl, const OFFSET: isize>() -> IMSMQDestination_Vtbl { unsafe extern "system" fn Open, Impl: IMSMQDestination_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -576,12 +576,12 @@ impl IMSMQDestination_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQEvent_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQEvent_Vtbl { pub const fn new, Impl: IMSMQEvent_Impl, const OFFSET: isize>() -> IMSMQEvent_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -590,14 +590,14 @@ impl IMSMQEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQEvent2_Impl: Sized + IMSMQEvent_Impl { fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQEvent2_Vtbl { pub const fn new, Impl: IMSMQEvent2_Impl, const OFFSET: isize>() -> IMSMQEvent2_Vtbl { unsafe extern "system" fn Properties, Impl: IMSMQEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -617,12 +617,12 @@ impl IMSMQEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQEvent3_Impl: Sized + IMSMQEvent2_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQEvent3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQEvent3_Vtbl { pub const fn new, Impl: IMSMQEvent3_Impl, const OFFSET: isize>() -> IMSMQEvent3_Vtbl { Self { base__: IMSMQEvent2_Vtbl::new::() } @@ -631,10 +631,10 @@ impl IMSMQEvent3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQManagement_Impl: Sized + super::Com::IDispatch_Impl { - fn Init(&self, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Init(&self, machine: *const ::windows_core::VARIANT, pathname: *const ::windows_core::VARIANT, formatname: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn FormatName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Machine(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn MessageCount(&self) -> ::windows_core::Result; @@ -642,14 +642,14 @@ pub trait IMSMQManagement_Impl: Sized + super::Com::IDispatch_Impl { fn QueueType(&self) -> ::windows_core::Result; fn IsLocal(&self) -> ::windows_core::Result; fn TransactionalStatus(&self) -> ::windows_core::Result; - fn BytesInQueue(&self) -> ::windows_core::Result; + fn BytesInQueue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQManagement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQManagement_Vtbl { pub const fn new, Impl: IMSMQManagement_Impl, const OFFSET: isize>() -> IMSMQManagement_Vtbl { - unsafe extern "system" fn Init, Impl: IMSMQManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Init, Impl: IMSMQManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, machine: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pathname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, formatname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Init(::core::mem::transmute_copy(&machine), ::core::mem::transmute_copy(&pathname), ::core::mem::transmute_copy(&formatname)).into() @@ -731,7 +731,7 @@ impl IMSMQManagement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BytesInQueue, Impl: IMSMQManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinqueue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BytesInQueue, Impl: IMSMQManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinqueue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BytesInQueue() { @@ -759,8 +759,8 @@ impl IMSMQManagement_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQMessage_Impl: Sized + super::Com::IDispatch_Impl { fn Class(&self) -> ::windows_core::Result; fn PrivLevel(&self) -> ::windows_core::Result; @@ -782,13 +782,13 @@ pub trait IMSMQMessage_Impl: Sized + super::Com::IDispatch_Impl { fn SetAppSpecific(&self, lappspecific: i32) -> ::windows_core::Result<()>; fn SourceMachineGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BodyLength(&self) -> ::windows_core::Result; - fn Body(&self) -> ::windows_core::Result; - fn SetBody(&self, varbody: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBody(&self, varbody: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AdminQueueInfo(&self) -> ::windows_core::Result; fn putref_AdminQueueInfo(&self, pqinfoadmin: ::core::option::Option<&IMSMQQueueInfo>) -> ::windows_core::Result<()>; - fn Id(&self) -> ::windows_core::Result; - fn CorrelationId(&self) -> ::windows_core::Result; - fn SetCorrelationId(&self, varmsgid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCorrelationId(&self, varmsgid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Ack(&self) -> ::windows_core::Result; fn SetAck(&self, lack: i32) -> ::windows_core::Result<()>; fn Label(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -801,20 +801,20 @@ pub trait IMSMQMessage_Impl: Sized + super::Com::IDispatch_Impl { fn SetHashAlgorithm(&self, lhashalg: i32) -> ::windows_core::Result<()>; fn EncryptAlgorithm(&self) -> ::windows_core::Result; fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()>; - fn SentTime(&self) -> ::windows_core::Result; - fn ArrivedTime(&self) -> ::windows_core::Result; + fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DestinationQueueInfo(&self) -> ::windows_core::Result; - fn SenderCertificate(&self) -> ::windows_core::Result; - fn SetSenderCertificate(&self, varsendercert: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SenderId(&self) -> ::windows_core::Result; + fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSenderCertificate(&self, varsendercert: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SenderIdType(&self) -> ::windows_core::Result; fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()>; - fn Send(&self, destinationqueue: ::core::option::Option<&IMSMQQueue>, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Send(&self, destinationqueue: ::core::option::Option<&IMSMQQueue>, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQMessage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQMessage_Vtbl { pub const fn new, Impl: IMSMQMessage_Impl, const OFFSET: isize>() -> IMSMQMessage_Vtbl { unsafe extern "system" fn Class, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plclass: *mut i32) -> ::windows_core::HRESULT { @@ -989,7 +989,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Body, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Body, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Body() { @@ -1000,7 +1000,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBody, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBody, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBody(::core::mem::transmute(&varbody)).into() @@ -1021,7 +1021,7 @@ impl IMSMQMessage_Vtbl { let this = (*this).get_impl(); this.putref_AdminQueueInfo(::windows_core::from_raw_borrowed(&pqinfoadmin)).into() } - unsafe extern "system" fn Id, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Id, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Id() { @@ -1032,7 +1032,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CorrelationId() { @@ -1043,7 +1043,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCorrelationId(::core::mem::transmute(&varmsgid)).into() @@ -1144,7 +1144,7 @@ impl IMSMQMessage_Vtbl { let this = (*this).get_impl(); this.SetEncryptAlgorithm(::core::mem::transmute_copy(&lencryptalg)).into() } - unsafe extern "system" fn SentTime, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SentTime, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SentTime() { @@ -1155,7 +1155,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ArrivedTime() { @@ -1177,7 +1177,7 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderCertificate() { @@ -1188,12 +1188,12 @@ impl IMSMQMessage_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderCertificate(::core::mem::transmute(&varsendercert)).into() } - unsafe extern "system" fn SenderId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderId, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderId() { @@ -1220,7 +1220,7 @@ impl IMSMQMessage_Vtbl { let this = (*this).get_impl(); this.SetSenderIdType(::core::mem::transmute_copy(&lsenderidtype)).into() } - unsafe extern "system" fn Send, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Send, Impl: IMSMQMessage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Send(::windows_core::from_raw_borrowed(&destinationqueue), ::core::mem::transmute_copy(&transaction)).into() @@ -1287,8 +1287,8 @@ impl IMSMQMessage_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQMessage2_Impl: Sized + super::Com::IDispatch_Impl { fn Class(&self) -> ::windows_core::Result; fn PrivLevel(&self) -> ::windows_core::Result; @@ -1310,13 +1310,13 @@ pub trait IMSMQMessage2_Impl: Sized + super::Com::IDispatch_Impl { fn SetAppSpecific(&self, lappspecific: i32) -> ::windows_core::Result<()>; fn SourceMachineGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BodyLength(&self) -> ::windows_core::Result; - fn Body(&self) -> ::windows_core::Result; - fn SetBody(&self, varbody: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBody(&self, varbody: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AdminQueueInfo_v1(&self) -> ::windows_core::Result; fn putref_AdminQueueInfo_v1(&self, pqinfoadmin: ::core::option::Option<&IMSMQQueueInfo>) -> ::windows_core::Result<()>; - fn Id(&self) -> ::windows_core::Result; - fn CorrelationId(&self) -> ::windows_core::Result; - fn SetCorrelationId(&self, varmsgid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCorrelationId(&self, varmsgid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Ack(&self) -> ::windows_core::Result; fn SetAck(&self, lack: i32) -> ::windows_core::Result<()>; fn Label(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1329,35 +1329,35 @@ pub trait IMSMQMessage2_Impl: Sized + super::Com::IDispatch_Impl { fn SetHashAlgorithm(&self, lhashalg: i32) -> ::windows_core::Result<()>; fn EncryptAlgorithm(&self) -> ::windows_core::Result; fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()>; - fn SentTime(&self) -> ::windows_core::Result; - fn ArrivedTime(&self) -> ::windows_core::Result; + fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DestinationQueueInfo(&self) -> ::windows_core::Result; - fn SenderCertificate(&self) -> ::windows_core::Result; - fn SetSenderCertificate(&self, varsendercert: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SenderId(&self) -> ::windows_core::Result; + fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSenderCertificate(&self, varsendercert: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SenderIdType(&self) -> ::windows_core::Result; fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()>; - fn Send(&self, destinationqueue: ::core::option::Option<&IMSMQQueue2>, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Send(&self, destinationqueue: ::core::option::Option<&IMSMQQueue2>, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()>; fn SenderVersion(&self) -> ::windows_core::Result; - fn Extension(&self) -> ::windows_core::Result; - fn SetExtension(&self, varextension: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtension(&self, varextension: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetConnectorTypeGuid(&self, bstrguidconnectortype: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TransactionStatusQueueInfo(&self) -> ::windows_core::Result; - fn DestinationSymmetricKey(&self) -> ::windows_core::Result; - fn SetDestinationSymmetricKey(&self, vardestsymmkey: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Signature(&self) -> ::windows_core::Result; - fn SetSignature(&self, varsignature: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDestinationSymmetricKey(&self, vardestsymmkey: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSignature(&self, varsignature: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AuthenticationProviderType(&self) -> ::windows_core::Result; fn SetAuthenticationProviderType(&self, lauthprovtype: i32) -> ::windows_core::Result<()>; fn AuthenticationProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAuthenticationProviderName(&self, bstrauthprovname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetSenderId(&self, varsenderid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSenderId(&self, varsenderid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MsgClass(&self) -> ::windows_core::Result; fn SetMsgClass(&self, lmsgclass: i32) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; - fn TransactionId(&self) -> ::windows_core::Result; + fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsFirstInTransaction(&self) -> ::windows_core::Result; fn IsLastInTransaction(&self) -> ::windows_core::Result; fn ResponseQueueInfo(&self) -> ::windows_core::Result; @@ -1366,9 +1366,9 @@ pub trait IMSMQMessage2_Impl: Sized + super::Com::IDispatch_Impl { fn putref_AdminQueueInfo(&self, pqinfoadmin: ::core::option::Option<&IMSMQQueueInfo2>) -> ::windows_core::Result<()>; fn ReceivedAuthenticationLevel(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQMessage2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQMessage2_Vtbl { pub const fn new, Impl: IMSMQMessage2_Impl, const OFFSET: isize>() -> IMSMQMessage2_Vtbl { unsafe extern "system" fn Class, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plclass: *mut i32) -> ::windows_core::HRESULT { @@ -1543,7 +1543,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Body, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Body, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Body() { @@ -1554,7 +1554,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBody, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBody, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBody(::core::mem::transmute(&varbody)).into() @@ -1575,7 +1575,7 @@ impl IMSMQMessage2_Vtbl { let this = (*this).get_impl(); this.putref_AdminQueueInfo_v1(::windows_core::from_raw_borrowed(&pqinfoadmin)).into() } - unsafe extern "system" fn Id, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Id, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Id() { @@ -1586,7 +1586,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CorrelationId() { @@ -1597,7 +1597,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCorrelationId(::core::mem::transmute(&varmsgid)).into() @@ -1698,7 +1698,7 @@ impl IMSMQMessage2_Vtbl { let this = (*this).get_impl(); this.SetEncryptAlgorithm(::core::mem::transmute_copy(&lencryptalg)).into() } - unsafe extern "system" fn SentTime, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SentTime, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SentTime() { @@ -1709,7 +1709,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ArrivedTime() { @@ -1731,7 +1731,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderCertificate() { @@ -1742,12 +1742,12 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderCertificate(::core::mem::transmute(&varsendercert)).into() } - unsafe extern "system" fn SenderId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderId() { @@ -1774,7 +1774,7 @@ impl IMSMQMessage2_Vtbl { let this = (*this).get_impl(); this.SetSenderIdType(::core::mem::transmute_copy(&lsenderidtype)).into() } - unsafe extern "system" fn Send, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Send, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Send(::windows_core::from_raw_borrowed(&destinationqueue), ::core::mem::transmute_copy(&transaction)).into() @@ -1795,7 +1795,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Extension, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Extension, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Extension() { @@ -1806,7 +1806,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtension, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtension, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtension(::core::mem::transmute(&varextension)).into() @@ -1838,7 +1838,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DestinationSymmetricKey() { @@ -1849,12 +1849,12 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDestinationSymmetricKey(::core::mem::transmute(&vardestsymmkey)).into() } - unsafe extern "system" fn Signature, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Signature, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Signature() { @@ -1865,7 +1865,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSignature, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSignature, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSignature(::core::mem::transmute(&varsignature)).into() @@ -1902,7 +1902,7 @@ impl IMSMQMessage2_Vtbl { let this = (*this).get_impl(); this.SetAuthenticationProviderName(::core::mem::transmute(&bstrauthprovname)).into() } - unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderId(::core::mem::transmute(&varsenderid)).into() @@ -1934,7 +1934,7 @@ impl IMSMQMessage2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn TransactionId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TransactionId, Impl: IMSMQMessage2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TransactionId() { @@ -2093,8 +2093,8 @@ impl IMSMQMessage2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQMessage3_Impl: Sized + super::Com::IDispatch_Impl { fn Class(&self) -> ::windows_core::Result; fn PrivLevel(&self) -> ::windows_core::Result; @@ -2116,13 +2116,13 @@ pub trait IMSMQMessage3_Impl: Sized + super::Com::IDispatch_Impl { fn SetAppSpecific(&self, lappspecific: i32) -> ::windows_core::Result<()>; fn SourceMachineGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BodyLength(&self) -> ::windows_core::Result; - fn Body(&self) -> ::windows_core::Result; - fn SetBody(&self, varbody: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBody(&self, varbody: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AdminQueueInfo_v1(&self) -> ::windows_core::Result; fn putref_AdminQueueInfo_v1(&self, pqinfoadmin: ::core::option::Option<&IMSMQQueueInfo>) -> ::windows_core::Result<()>; - fn Id(&self) -> ::windows_core::Result; - fn CorrelationId(&self) -> ::windows_core::Result; - fn SetCorrelationId(&self, varmsgid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCorrelationId(&self, varmsgid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Ack(&self) -> ::windows_core::Result; fn SetAck(&self, lack: i32) -> ::windows_core::Result<()>; fn Label(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2135,35 +2135,35 @@ pub trait IMSMQMessage3_Impl: Sized + super::Com::IDispatch_Impl { fn SetHashAlgorithm(&self, lhashalg: i32) -> ::windows_core::Result<()>; fn EncryptAlgorithm(&self) -> ::windows_core::Result; fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()>; - fn SentTime(&self) -> ::windows_core::Result; - fn ArrivedTime(&self) -> ::windows_core::Result; + fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DestinationQueueInfo(&self) -> ::windows_core::Result; - fn SenderCertificate(&self) -> ::windows_core::Result; - fn SetSenderCertificate(&self, varsendercert: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SenderId(&self) -> ::windows_core::Result; + fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSenderCertificate(&self, varsendercert: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SenderIdType(&self) -> ::windows_core::Result; fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()>; - fn Send(&self, destinationqueue: ::core::option::Option<&super::Com::IDispatch>, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Send(&self, destinationqueue: ::core::option::Option<&super::Com::IDispatch>, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()>; fn SenderVersion(&self) -> ::windows_core::Result; - fn Extension(&self) -> ::windows_core::Result; - fn SetExtension(&self, varextension: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtension(&self, varextension: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetConnectorTypeGuid(&self, bstrguidconnectortype: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TransactionStatusQueueInfo(&self) -> ::windows_core::Result; - fn DestinationSymmetricKey(&self) -> ::windows_core::Result; - fn SetDestinationSymmetricKey(&self, vardestsymmkey: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Signature(&self) -> ::windows_core::Result; - fn SetSignature(&self, varsignature: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDestinationSymmetricKey(&self, vardestsymmkey: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSignature(&self, varsignature: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AuthenticationProviderType(&self) -> ::windows_core::Result; fn SetAuthenticationProviderType(&self, lauthprovtype: i32) -> ::windows_core::Result<()>; fn AuthenticationProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAuthenticationProviderName(&self, bstrauthprovname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetSenderId(&self, varsenderid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSenderId(&self, varsenderid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MsgClass(&self) -> ::windows_core::Result; fn SetMsgClass(&self, lmsgclass: i32) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; - fn TransactionId(&self) -> ::windows_core::Result; + fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsFirstInTransaction(&self) -> ::windows_core::Result; fn IsLastInTransaction(&self) -> ::windows_core::Result; fn ResponseQueueInfo_v2(&self) -> ::windows_core::Result; @@ -2178,19 +2178,19 @@ pub trait IMSMQMessage3_Impl: Sized + super::Com::IDispatch_Impl { fn ResponseDestination(&self) -> ::windows_core::Result; fn putref_ResponseDestination(&self, pdestresponse: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn Destination(&self) -> ::windows_core::Result; - fn LookupId(&self) -> ::windows_core::Result; + fn LookupId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsAuthenticated2(&self) -> ::windows_core::Result; fn IsFirstInTransaction2(&self) -> ::windows_core::Result; fn IsLastInTransaction2(&self) -> ::windows_core::Result; fn AttachCurrentSecurityContext2(&self) -> ::windows_core::Result<()>; fn SoapEnvelope(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn CompoundMessage(&self) -> ::windows_core::Result; + fn CompoundMessage(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetSoapHeader(&self, bstrsoapheader: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSoapBody(&self, bstrsoapbody: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQMessage3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQMessage3_Vtbl { pub const fn new, Impl: IMSMQMessage3_Impl, const OFFSET: isize>() -> IMSMQMessage3_Vtbl { unsafe extern "system" fn Class, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plclass: *mut i32) -> ::windows_core::HRESULT { @@ -2365,7 +2365,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Body, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Body, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Body() { @@ -2376,7 +2376,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBody, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBody, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBody(::core::mem::transmute(&varbody)).into() @@ -2397,7 +2397,7 @@ impl IMSMQMessage3_Vtbl { let this = (*this).get_impl(); this.putref_AdminQueueInfo_v1(::windows_core::from_raw_borrowed(&pqinfoadmin)).into() } - unsafe extern "system" fn Id, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Id, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Id() { @@ -2408,7 +2408,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CorrelationId() { @@ -2419,7 +2419,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCorrelationId(::core::mem::transmute(&varmsgid)).into() @@ -2520,7 +2520,7 @@ impl IMSMQMessage3_Vtbl { let this = (*this).get_impl(); this.SetEncryptAlgorithm(::core::mem::transmute_copy(&lencryptalg)).into() } - unsafe extern "system" fn SentTime, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SentTime, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SentTime() { @@ -2531,7 +2531,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ArrivedTime() { @@ -2553,7 +2553,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderCertificate() { @@ -2564,12 +2564,12 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderCertificate(::core::mem::transmute(&varsendercert)).into() } - unsafe extern "system" fn SenderId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderId() { @@ -2596,7 +2596,7 @@ impl IMSMQMessage3_Vtbl { let this = (*this).get_impl(); this.SetSenderIdType(::core::mem::transmute_copy(&lsenderidtype)).into() } - unsafe extern "system" fn Send, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Send, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Send(::windows_core::from_raw_borrowed(&destinationqueue), ::core::mem::transmute_copy(&transaction)).into() @@ -2617,7 +2617,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Extension, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Extension, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Extension() { @@ -2628,7 +2628,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtension, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtension, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtension(::core::mem::transmute(&varextension)).into() @@ -2660,7 +2660,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DestinationSymmetricKey() { @@ -2671,12 +2671,12 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDestinationSymmetricKey(::core::mem::transmute(&vardestsymmkey)).into() } - unsafe extern "system" fn Signature, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Signature, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Signature() { @@ -2687,7 +2687,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSignature, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSignature, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSignature(::core::mem::transmute(&varsignature)).into() @@ -2724,7 +2724,7 @@ impl IMSMQMessage3_Vtbl { let this = (*this).get_impl(); this.SetAuthenticationProviderName(::core::mem::transmute(&bstrauthprovname)).into() } - unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderId(::core::mem::transmute(&varsenderid)).into() @@ -2756,7 +2756,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn TransactionId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TransactionId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TransactionId() { @@ -2891,7 +2891,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LookupId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlookupid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupId, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlookupid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupId() { @@ -2951,7 +2951,7 @@ impl IMSMQMessage3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CompoundMessage, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CompoundMessage, Impl: IMSMQMessage3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CompoundMessage() { @@ -3071,8 +3071,8 @@ impl IMSMQMessage3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQMessage4_Impl: Sized + super::Com::IDispatch_Impl { fn Class(&self) -> ::windows_core::Result; fn PrivLevel(&self) -> ::windows_core::Result; @@ -3094,13 +3094,13 @@ pub trait IMSMQMessage4_Impl: Sized + super::Com::IDispatch_Impl { fn SetAppSpecific(&self, lappspecific: i32) -> ::windows_core::Result<()>; fn SourceMachineGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BodyLength(&self) -> ::windows_core::Result; - fn Body(&self) -> ::windows_core::Result; - fn SetBody(&self, varbody: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetBody(&self, varbody: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AdminQueueInfo_v1(&self) -> ::windows_core::Result; fn putref_AdminQueueInfo_v1(&self, pqinfoadmin: ::core::option::Option<&IMSMQQueueInfo>) -> ::windows_core::Result<()>; - fn Id(&self) -> ::windows_core::Result; - fn CorrelationId(&self) -> ::windows_core::Result; - fn SetCorrelationId(&self, varmsgid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetCorrelationId(&self, varmsgid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Ack(&self) -> ::windows_core::Result; fn SetAck(&self, lack: i32) -> ::windows_core::Result<()>; fn Label(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3113,35 +3113,35 @@ pub trait IMSMQMessage4_Impl: Sized + super::Com::IDispatch_Impl { fn SetHashAlgorithm(&self, lhashalg: i32) -> ::windows_core::Result<()>; fn EncryptAlgorithm(&self) -> ::windows_core::Result; fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()>; - fn SentTime(&self) -> ::windows_core::Result; - fn ArrivedTime(&self) -> ::windows_core::Result; + fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DestinationQueueInfo(&self) -> ::windows_core::Result; - fn SenderCertificate(&self) -> ::windows_core::Result; - fn SetSenderCertificate(&self, varsendercert: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SenderId(&self) -> ::windows_core::Result; + fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSenderCertificate(&self, varsendercert: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SenderIdType(&self) -> ::windows_core::Result; fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()>; - fn Send(&self, destinationqueue: ::core::option::Option<&super::Com::IDispatch>, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Send(&self, destinationqueue: ::core::option::Option<&super::Com::IDispatch>, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()>; fn SenderVersion(&self) -> ::windows_core::Result; - fn Extension(&self) -> ::windows_core::Result; - fn SetExtension(&self, varextension: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetExtension(&self, varextension: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetConnectorTypeGuid(&self, bstrguidconnectortype: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn TransactionStatusQueueInfo(&self) -> ::windows_core::Result; - fn DestinationSymmetricKey(&self) -> ::windows_core::Result; - fn SetDestinationSymmetricKey(&self, vardestsymmkey: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Signature(&self) -> ::windows_core::Result; - fn SetSignature(&self, varsignature: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDestinationSymmetricKey(&self, vardestsymmkey: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSignature(&self, varsignature: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AuthenticationProviderType(&self) -> ::windows_core::Result; fn SetAuthenticationProviderType(&self, lauthprovtype: i32) -> ::windows_core::Result<()>; fn AuthenticationProviderName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAuthenticationProviderName(&self, bstrauthprovname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetSenderId(&self, varsenderid: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSenderId(&self, varsenderid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MsgClass(&self) -> ::windows_core::Result; fn SetMsgClass(&self, lmsgclass: i32) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; - fn TransactionId(&self) -> ::windows_core::Result; + fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsFirstInTransaction(&self) -> ::windows_core::Result; fn IsLastInTransaction(&self) -> ::windows_core::Result; fn ResponseQueueInfo_v2(&self) -> ::windows_core::Result; @@ -3156,19 +3156,19 @@ pub trait IMSMQMessage4_Impl: Sized + super::Com::IDispatch_Impl { fn ResponseDestination(&self) -> ::windows_core::Result; fn putref_ResponseDestination(&self, pdestresponse: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn Destination(&self) -> ::windows_core::Result; - fn LookupId(&self) -> ::windows_core::Result; + fn LookupId(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsAuthenticated2(&self) -> ::windows_core::Result; fn IsFirstInTransaction2(&self) -> ::windows_core::Result; fn IsLastInTransaction2(&self) -> ::windows_core::Result; fn AttachCurrentSecurityContext2(&self) -> ::windows_core::Result<()>; fn SoapEnvelope(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn CompoundMessage(&self) -> ::windows_core::Result; + fn CompoundMessage(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetSoapHeader(&self, bstrsoapheader: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSoapBody(&self, bstrsoapbody: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQMessage4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQMessage4_Vtbl { pub const fn new, Impl: IMSMQMessage4_Impl, const OFFSET: isize>() -> IMSMQMessage4_Vtbl { unsafe extern "system" fn Class, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plclass: *mut i32) -> ::windows_core::HRESULT { @@ -3343,7 +3343,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Body, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Body, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Body() { @@ -3354,7 +3354,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetBody, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetBody, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetBody(::core::mem::transmute(&varbody)).into() @@ -3375,7 +3375,7 @@ impl IMSMQMessage4_Vtbl { let this = (*this).get_impl(); this.putref_AdminQueueInfo_v1(::windows_core::from_raw_borrowed(&pqinfoadmin)).into() } - unsafe extern "system" fn Id, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Id, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Id() { @@ -3386,7 +3386,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CorrelationId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CorrelationId() { @@ -3397,7 +3397,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCorrelationId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCorrelationId(::core::mem::transmute(&varmsgid)).into() @@ -3498,7 +3498,7 @@ impl IMSMQMessage4_Vtbl { let this = (*this).get_impl(); this.SetEncryptAlgorithm(::core::mem::transmute_copy(&lencryptalg)).into() } - unsafe extern "system" fn SentTime, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SentTime, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SentTime() { @@ -3509,7 +3509,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ArrivedTime, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ArrivedTime() { @@ -3531,7 +3531,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderCertificate, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderCertificate() { @@ -3542,12 +3542,12 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderCertificate, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderCertificate(::core::mem::transmute(&varsendercert)).into() } - unsafe extern "system" fn SenderId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SenderId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SenderId() { @@ -3574,7 +3574,7 @@ impl IMSMQMessage4_Vtbl { let this = (*this).get_impl(); this.SetSenderIdType(::core::mem::transmute_copy(&lsenderidtype)).into() } - unsafe extern "system" fn Send, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Send, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Send(::windows_core::from_raw_borrowed(&destinationqueue), ::core::mem::transmute_copy(&transaction)).into() @@ -3595,7 +3595,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Extension, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Extension, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Extension() { @@ -3606,7 +3606,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetExtension, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetExtension, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetExtension(::core::mem::transmute(&varextension)).into() @@ -3638,7 +3638,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DestinationSymmetricKey, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DestinationSymmetricKey() { @@ -3649,12 +3649,12 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDestinationSymmetricKey, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDestinationSymmetricKey(::core::mem::transmute(&vardestsymmkey)).into() } - unsafe extern "system" fn Signature, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Signature, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Signature() { @@ -3665,7 +3665,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSignature, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSignature, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSignature(::core::mem::transmute(&varsignature)).into() @@ -3702,7 +3702,7 @@ impl IMSMQMessage4_Vtbl { let this = (*this).get_impl(); this.SetAuthenticationProviderName(::core::mem::transmute(&bstrauthprovname)).into() } - unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSenderId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSenderId(::core::mem::transmute(&varsenderid)).into() @@ -3734,7 +3734,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn TransactionId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TransactionId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.TransactionId() { @@ -3869,7 +3869,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LookupId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlookupid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupId, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarlookupid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupId() { @@ -3929,7 +3929,7 @@ impl IMSMQMessage4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CompoundMessage, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CompoundMessage, Impl: IMSMQMessage4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CompoundMessage() { @@ -4049,19 +4049,19 @@ impl IMSMQMessage4_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQOutgoingQueueManagement_Impl: Sized + IMSMQManagement_Impl { fn State(&self) -> ::windows_core::Result; - fn NextHops(&self) -> ::windows_core::Result; + fn NextHops(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn EodGetSendInfo(&self) -> ::windows_core::Result; fn Resume(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; fn EodResend(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQOutgoingQueueManagement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQOutgoingQueueManagement_Vtbl { pub const fn new, Impl: IMSMQOutgoingQueueManagement_Impl, const OFFSET: isize>() -> IMSMQOutgoingQueueManagement_Vtbl { unsafe extern "system" fn State, Impl: IMSMQOutgoingQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plstate: *mut i32) -> ::windows_core::HRESULT { @@ -4075,7 +4075,7 @@ impl IMSMQOutgoingQueueManagement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NextHops, Impl: IMSMQOutgoingQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvnexthops: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NextHops, Impl: IMSMQOutgoingQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvnexthops: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NextHops() { @@ -4126,18 +4126,18 @@ impl IMSMQOutgoingQueueManagement_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQPrivateDestination_Impl: Sized + super::Com::IDispatch_Impl { - fn Handle(&self) -> ::windows_core::Result; - fn SetHandle(&self, varhandle: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Handle(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetHandle(&self, varhandle: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQPrivateDestination {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQPrivateDestination_Vtbl { pub const fn new, Impl: IMSMQPrivateDestination_Impl, const OFFSET: isize>() -> IMSMQPrivateDestination_Vtbl { - unsafe extern "system" fn Handle, Impl: IMSMQPrivateDestination_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Handle, Impl: IMSMQPrivateDestination_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Handle() { @@ -4148,7 +4148,7 @@ impl IMSMQPrivateDestination_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetHandle, Impl: IMSMQPrivateDestination_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varhandle: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetHandle, Impl: IMSMQPrivateDestination_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varhandle: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetHandle(::core::mem::transmute(&varhandle)).into() @@ -4163,16 +4163,16 @@ impl IMSMQPrivateDestination_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQPrivateEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Hwnd(&self) -> ::windows_core::Result; fn FireArrivedEvent(&self, pq: ::core::option::Option<&IMSMQQueue>, msgcursor: i32) -> ::windows_core::Result<()>; fn FireArrivedErrorEvent(&self, pq: ::core::option::Option<&IMSMQQueue>, hrstatus: ::windows_core::HRESULT, msgcursor: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQPrivateEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQPrivateEvent_Vtbl { pub const fn new, Impl: IMSMQPrivateEvent_Impl, const OFFSET: isize>() -> IMSMQPrivateEvent_Vtbl { unsafe extern "system" fn Hwnd, Impl: IMSMQPrivateEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phwnd: *mut i32) -> ::windows_core::HRESULT { @@ -4207,17 +4207,29 @@ impl IMSMQPrivateEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQuery_Impl: Sized + super::Com::IDispatch_Impl { - fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQuery {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQuery_Vtbl { pub const fn new, Impl: IMSMQQuery_Impl, const OFFSET: isize>() -> IMSMQQuery_Vtbl { - unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue(::core::mem::transmute_copy(&queueguid), ::core::mem::transmute_copy(&servicetypeguid), ::core::mem::transmute_copy(&label), ::core::mem::transmute_copy(&createtime), ::core::mem::transmute_copy(&modifytime), ::core::mem::transmute_copy(&relservicetype), ::core::mem::transmute_copy(&rellabel), ::core::mem::transmute_copy(&relcreatetime), ::core::mem::transmute_copy(&relmodifytime)) { @@ -4234,18 +4246,30 @@ impl IMSMQQuery_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQuery2_Impl: Sized + super::Com::IDispatch_Impl { - fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQuery2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQuery2_Vtbl { pub const fn new, Impl: IMSMQQuery2_Impl, const OFFSET: isize>() -> IMSMQQuery2_Vtbl { - unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery2_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue(::core::mem::transmute_copy(&queueguid), ::core::mem::transmute_copy(&servicetypeguid), ::core::mem::transmute_copy(&label), ::core::mem::transmute_copy(&createtime), ::core::mem::transmute_copy(&modifytime), ::core::mem::transmute_copy(&relservicetype), ::core::mem::transmute_copy(&rellabel), ::core::mem::transmute_copy(&relcreatetime), ::core::mem::transmute_copy(&relmodifytime)) { @@ -4277,19 +4301,31 @@ impl IMSMQQuery2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQuery3_Impl: Sized + super::Com::IDispatch_Impl { - fn LookupQueue_v2(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue_v2(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; - fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT, multicastaddress: *const ::windows_core::VARIANT, relmulticastaddress: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQuery3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQuery3_Vtbl { pub const fn new, Impl: IMSMQQuery3_Impl, const OFFSET: isize>() -> IMSMQQuery3_Vtbl { - unsafe extern "system" fn LookupQueue_v2, Impl: IMSMQQuery3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue_v2, Impl: IMSMQQuery3_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue_v2(::core::mem::transmute_copy(&queueguid), ::core::mem::transmute_copy(&servicetypeguid), ::core::mem::transmute_copy(&label), ::core::mem::transmute_copy(&createtime), ::core::mem::transmute_copy(&modifytime), ::core::mem::transmute_copy(&relservicetype), ::core::mem::transmute_copy(&rellabel), ::core::mem::transmute_copy(&relcreatetime), ::core::mem::transmute_copy(&relmodifytime)) { @@ -4311,7 +4347,21 @@ impl IMSMQQuery3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery3_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + multicastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmulticastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue( @@ -4345,19 +4395,31 @@ impl IMSMQQuery3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQuery4_Impl: Sized + super::Com::IDispatch_Impl { - fn LookupQueue_v2(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue_v2(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; - fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT, multicastaddress: *const ::windows_core::VARIANT, relmulticastaddress: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQuery4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQuery4_Vtbl { pub const fn new, Impl: IMSMQQuery4_Impl, const OFFSET: isize>() -> IMSMQQuery4_Vtbl { - unsafe extern "system" fn LookupQueue_v2, Impl: IMSMQQuery4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue_v2, Impl: IMSMQQuery4_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue_v2(::core::mem::transmute_copy(&queueguid), ::core::mem::transmute_copy(&servicetypeguid), ::core::mem::transmute_copy(&label), ::core::mem::transmute_copy(&createtime), ::core::mem::transmute_copy(&modifytime), ::core::mem::transmute_copy(&relservicetype), ::core::mem::transmute_copy(&rellabel), ::core::mem::transmute_copy(&relcreatetime), ::core::mem::transmute_copy(&relmodifytime)) { @@ -4379,7 +4441,21 @@ impl IMSMQQuery4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn LookupQueue, Impl: IMSMQQuery4_Impl, const OFFSET: isize>( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + multicastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmulticastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LookupQueue( @@ -4413,8 +4489,8 @@ impl IMSMQQuery4_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueue_Impl: Sized + super::Com::IDispatch_Impl { fn Access(&self) -> ::windows_core::Result; fn ShareMode(&self) -> ::windows_core::Result; @@ -4422,17 +4498,17 @@ pub trait IMSMQQueue_Impl: Sized + super::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; fn IsOpen(&self) -> ::windows_core::Result; fn Close(&self) -> ::windows_core::Result<()>; - fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent>, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent>, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; - fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueue_Vtbl { pub const fn new, Impl: IMSMQQueue_Impl, const OFFSET: isize>() -> IMSMQQueue_Vtbl { unsafe extern "system" fn Access, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, placcess: *mut i32) -> ::windows_core::HRESULT { @@ -4495,7 +4571,7 @@ impl IMSMQQueue_Vtbl { let this = (*this).get_impl(); this.Close().into() } - unsafe extern "system" fn Receive, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4506,7 +4582,7 @@ impl IMSMQQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4517,7 +4593,7 @@ impl IMSMQQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnableNotification(::windows_core::from_raw_borrowed(&event), ::core::mem::transmute_copy(&cursor), ::core::mem::transmute_copy(&receivetimeout)).into() @@ -4527,7 +4603,7 @@ impl IMSMQQueue_Vtbl { let this = (*this).get_impl(); this.Reset().into() } - unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4538,7 +4614,7 @@ impl IMSMQQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4549,7 +4625,7 @@ impl IMSMQQueue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4581,8 +4657,8 @@ impl IMSMQQueue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueue2_Impl: Sized + super::Com::IDispatch_Impl { fn Access(&self) -> ::windows_core::Result; fn ShareMode(&self) -> ::windows_core::Result; @@ -4590,23 +4666,23 @@ pub trait IMSMQQueue2_Impl: Sized + super::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; fn IsOpen(&self) -> ::windows_core::Result; fn Close(&self) -> ::windows_core::Result<()>; - fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent2>, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent2>, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; - fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueue2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueue2_Vtbl { pub const fn new, Impl: IMSMQQueue2_Impl, const OFFSET: isize>() -> IMSMQQueue2_Vtbl { unsafe extern "system" fn Access, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, placcess: *mut i32) -> ::windows_core::HRESULT { @@ -4669,7 +4745,7 @@ impl IMSMQQueue2_Vtbl { let this = (*this).get_impl(); this.Close().into() } - unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4680,7 +4756,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4691,7 +4767,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnableNotification(::windows_core::from_raw_borrowed(&event), ::core::mem::transmute_copy(&cursor), ::core::mem::transmute_copy(&receivetimeout)).into() @@ -4701,7 +4777,7 @@ impl IMSMQQueue2_Vtbl { let this = (*this).get_impl(); this.Reset().into() } - unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4712,7 +4788,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4723,7 +4799,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4734,7 +4810,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Receive, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -4745,7 +4821,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -4756,7 +4832,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -4767,7 +4843,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -4778,7 +4854,7 @@ impl IMSMQQueue2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -4827,8 +4903,8 @@ impl IMSMQQueue2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueue3_Impl: Sized + super::Com::IDispatch_Impl { fn Access(&self) -> ::windows_core::Result; fn ShareMode(&self) -> ::windows_core::Result; @@ -4836,36 +4912,36 @@ pub trait IMSMQQueue3_Impl: Sized + super::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; fn IsOpen(&self) -> ::windows_core::Result; fn Close(&self) -> ::windows_core::Result<()>; - fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent3>, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent3>, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; - fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; - fn Handle2(&self) -> ::windows_core::Result; - fn ReceiveByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveNextByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceivePreviousByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveFirstByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveLastByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNextByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekPreviousByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekFirstByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekLastByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn Handle2(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ReceiveByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveNextByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceivePreviousByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveFirstByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveLastByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNextByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekPreviousByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekFirstByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekLastByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Purge(&self) -> ::windows_core::Result<()>; fn IsOpen2(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueue3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueue3_Vtbl { pub const fn new, Impl: IMSMQQueue3_Impl, const OFFSET: isize>() -> IMSMQQueue3_Vtbl { unsafe extern "system" fn Access, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, placcess: *mut i32) -> ::windows_core::HRESULT { @@ -4928,7 +5004,7 @@ impl IMSMQQueue3_Vtbl { let this = (*this).get_impl(); this.Close().into() } - unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4939,7 +5015,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4950,7 +5026,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnableNotification(::windows_core::from_raw_borrowed(&event), ::core::mem::transmute_copy(&cursor), ::core::mem::transmute_copy(&receivetimeout)).into() @@ -4960,7 +5036,7 @@ impl IMSMQQueue3_Vtbl { let this = (*this).get_impl(); this.Reset().into() } - unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4971,7 +5047,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4982,7 +5058,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -4993,7 +5069,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Receive, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5004,7 +5080,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5015,7 +5091,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5026,7 +5102,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5037,7 +5113,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5059,7 +5135,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Handle2, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Handle2, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Handle2() { @@ -5070,7 +5146,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5081,7 +5157,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveNextByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveNextByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveNextByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5092,7 +5168,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceivePreviousByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceivePreviousByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceivePreviousByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5103,7 +5179,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveFirstByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveFirstByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveFirstByLookupId(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5114,7 +5190,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveLastByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveLastByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveLastByLookupId(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5125,7 +5201,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5136,7 +5212,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNextByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNextByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNextByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5147,7 +5223,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekPreviousByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekPreviousByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekPreviousByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5158,7 +5234,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekFirstByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekFirstByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekFirstByLookupId(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5169,7 +5245,7 @@ impl IMSMQQueue3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekLastByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekLastByLookupId, Impl: IMSMQQueue3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekLastByLookupId(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5236,8 +5312,8 @@ impl IMSMQQueue3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueue4_Impl: Sized + super::Com::IDispatch_Impl { fn Access(&self) -> ::windows_core::Result; fn ShareMode(&self) -> ::windows_core::Result; @@ -5245,37 +5321,37 @@ pub trait IMSMQQueue4_Impl: Sized + super::Com::IDispatch_Impl { fn Handle(&self) -> ::windows_core::Result; fn IsOpen(&self) -> ::windows_core::Result; fn Close(&self) -> ::windows_core::Result<()>; - fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent3>, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn EnableNotification(&self, event: ::core::option::Option<&IMSMQEvent3>, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; - fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; - fn Handle2(&self) -> ::windows_core::Result; - fn ReceiveByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveNextByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceivePreviousByLookupId(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveFirstByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn ReceiveLastByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekNextByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekPreviousByLookupId(&self, lookupid: &super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekFirstByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; - fn PeekLastByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn Handle2(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ReceiveByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveNextByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceivePreviousByLookupId(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveFirstByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn ReceiveLastByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekNextByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekPreviousByLookupId(&self, lookupid: &::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekFirstByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; + fn PeekLastByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn Purge(&self) -> ::windows_core::Result<()>; fn IsOpen2(&self) -> ::windows_core::Result; - fn ReceiveByLookupIdAllowPeek(&self, lookupid: &super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn ReceiveByLookupIdAllowPeek(&self, lookupid: &::windows_core::VARIANT, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueue4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueue4_Vtbl { pub const fn new, Impl: IMSMQQueue4_Impl, const OFFSET: isize>() -> IMSMQQueue4_Vtbl { unsafe extern "system" fn Access, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, placcess: *mut i32) -> ::windows_core::HRESULT { @@ -5338,7 +5414,7 @@ impl IMSMQQueue4_Vtbl { let this = (*this).get_impl(); this.Close().into() } - unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -5349,7 +5425,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -5360,7 +5436,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnableNotification, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnableNotification(::windows_core::from_raw_borrowed(&event), ::core::mem::transmute_copy(&cursor), ::core::mem::transmute_copy(&receivetimeout)).into() @@ -5370,7 +5446,7 @@ impl IMSMQQueue4_Vtbl { let this = (*this).get_impl(); this.Reset().into() } - unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent_v1(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -5381,7 +5457,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -5392,7 +5468,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent_v1, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent_v1(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout)) { @@ -5403,7 +5479,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Receive, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Receive, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Receive(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5414,7 +5490,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Peek, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Peek, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Peek(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5425,7 +5501,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveCurrent, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveCurrent(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5436,7 +5512,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNext, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNext, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNext(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5447,7 +5523,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekCurrent, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekCurrent(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&receivetimeout), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5469,7 +5545,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Handle2, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Handle2, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Handle2() { @@ -5480,7 +5556,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5491,7 +5567,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveNextByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveNextByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveNextByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5502,7 +5578,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceivePreviousByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceivePreviousByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceivePreviousByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5513,7 +5589,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveFirstByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveFirstByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveFirstByLookupId(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5524,7 +5600,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveLastByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveLastByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveLastByLookupId(::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5535,7 +5611,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5546,7 +5622,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekNextByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekNextByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekNextByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5557,7 +5633,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekPreviousByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekPreviousByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekPreviousByLookupId(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5568,7 +5644,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekFirstByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekFirstByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekFirstByLookupId(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5579,7 +5655,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PeekLastByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn PeekLastByLookupId, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PeekLastByLookupId(::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5606,7 +5682,7 @@ impl IMSMQQueue4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ReceiveByLookupIdAllowPeek, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReceiveByLookupIdAllowPeek, Impl: IMSMQQueue4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ReceiveByLookupIdAllowPeek(::core::mem::transmute(&lookupid), ::core::mem::transmute_copy(&transaction), ::core::mem::transmute_copy(&wantdestinationqueue), ::core::mem::transmute_copy(&wantbody), ::core::mem::transmute_copy(&wantconnectortype)) { @@ -5658,8 +5734,8 @@ impl IMSMQQueue4_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfo_Impl: Sized + super::Com::IDispatch_Impl { fn QueueGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ServiceTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5679,22 +5755,22 @@ pub trait IMSMQQueueInfo_Impl: Sized + super::Com::IDispatch_Impl { fn SetQuota(&self, lquota: i32) -> ::windows_core::Result<()>; fn BasePriority(&self) -> ::windows_core::Result; fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()>; - fn CreateTime(&self) -> ::windows_core::Result; - fn ModifyTime(&self) -> ::windows_core::Result; + fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Authenticate(&self) -> ::windows_core::Result; fn SetAuthenticate(&self, lauthenticate: i32) -> ::windows_core::Result<()>; fn JournalQuota(&self) -> ::windows_core::Result; fn SetJournalQuota(&self, ljournalquota: i32) -> ::windows_core::Result<()>; fn IsWorldReadable(&self) -> ::windows_core::Result; - fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; fn Open(&self, access: i32, sharemode: i32) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Update(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfo_Vtbl { pub const fn new, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>() -> IMSMQQueueInfo_Vtbl { unsafe extern "system" fn QueueGuid, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrguidqueue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5847,7 +5923,7 @@ impl IMSMQQueueInfo_Vtbl { let this = (*this).get_impl(); this.SetBasePriority(::core::mem::transmute_copy(&lbasepriority)).into() } - unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTime() { @@ -5858,7 +5934,7 @@ impl IMSMQQueueInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ModifyTime() { @@ -5912,7 +5988,7 @@ impl IMSMQQueueInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IMSMQQueueInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Create(::core::mem::transmute_copy(&istransactional), ::core::mem::transmute_copy(&isworldreadable)).into() @@ -5981,8 +6057,8 @@ impl IMSMQQueueInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfo2_Impl: Sized + super::Com::IDispatch_Impl { fn QueueGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ServiceTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6002,26 +6078,26 @@ pub trait IMSMQQueueInfo2_Impl: Sized + super::Com::IDispatch_Impl { fn SetQuota(&self, lquota: i32) -> ::windows_core::Result<()>; fn BasePriority(&self) -> ::windows_core::Result; fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()>; - fn CreateTime(&self) -> ::windows_core::Result; - fn ModifyTime(&self) -> ::windows_core::Result; + fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Authenticate(&self) -> ::windows_core::Result; fn SetAuthenticate(&self, lauthenticate: i32) -> ::windows_core::Result<()>; fn JournalQuota(&self) -> ::windows_core::Result; fn SetJournalQuota(&self, ljournalquota: i32) -> ::windows_core::Result<()>; fn IsWorldReadable(&self) -> ::windows_core::Result; - fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; fn Open(&self, access: i32, sharemode: i32) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Update(&self) -> ::windows_core::Result<()>; fn PathNameDNS(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Properties(&self) -> ::windows_core::Result; - fn Security(&self) -> ::windows_core::Result; - fn SetSecurity(&self, varsecurity: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSecurity(&self, varsecurity: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfo2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfo2_Vtbl { pub const fn new, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>() -> IMSMQQueueInfo2_Vtbl { unsafe extern "system" fn QueueGuid, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrguidqueue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6174,7 +6250,7 @@ impl IMSMQQueueInfo2_Vtbl { let this = (*this).get_impl(); this.SetBasePriority(::core::mem::transmute_copy(&lbasepriority)).into() } - unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTime() { @@ -6185,7 +6261,7 @@ impl IMSMQQueueInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ModifyTime() { @@ -6239,7 +6315,7 @@ impl IMSMQQueueInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Create(::core::mem::transmute_copy(&istransactional), ::core::mem::transmute_copy(&isworldreadable)).into() @@ -6292,7 +6368,7 @@ impl IMSMQQueueInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Security, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Security, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Security() { @@ -6303,7 +6379,7 @@ impl IMSMQQueueInfo2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSecurity(::core::mem::transmute(&varsecurity)).into() @@ -6350,8 +6426,8 @@ impl IMSMQQueueInfo2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfo3_Impl: Sized + super::Com::IDispatch_Impl { fn QueueGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ServiceTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6371,31 +6447,31 @@ pub trait IMSMQQueueInfo3_Impl: Sized + super::Com::IDispatch_Impl { fn SetQuota(&self, lquota: i32) -> ::windows_core::Result<()>; fn BasePriority(&self) -> ::windows_core::Result; fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()>; - fn CreateTime(&self) -> ::windows_core::Result; - fn ModifyTime(&self) -> ::windows_core::Result; + fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Authenticate(&self) -> ::windows_core::Result; fn SetAuthenticate(&self, lauthenticate: i32) -> ::windows_core::Result<()>; fn JournalQuota(&self) -> ::windows_core::Result; fn SetJournalQuota(&self, ljournalquota: i32) -> ::windows_core::Result<()>; fn IsWorldReadable(&self) -> ::windows_core::Result; - fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; fn Open(&self, access: i32, sharemode: i32) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Update(&self) -> ::windows_core::Result<()>; fn PathNameDNS(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Properties(&self) -> ::windows_core::Result; - fn Security(&self) -> ::windows_core::Result; - fn SetSecurity(&self, varsecurity: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSecurity(&self, varsecurity: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn IsTransactional2(&self) -> ::windows_core::Result; fn IsWorldReadable2(&self) -> ::windows_core::Result; fn MulticastAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMulticastAddress(&self, bstrmulticastaddress: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ADsPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfo3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfo3_Vtbl { pub const fn new, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>() -> IMSMQQueueInfo3_Vtbl { unsafe extern "system" fn QueueGuid, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrguidqueue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6548,7 +6624,7 @@ impl IMSMQQueueInfo3_Vtbl { let this = (*this).get_impl(); this.SetBasePriority(::core::mem::transmute_copy(&lbasepriority)).into() } - unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTime() { @@ -6559,7 +6635,7 @@ impl IMSMQQueueInfo3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ModifyTime() { @@ -6613,7 +6689,7 @@ impl IMSMQQueueInfo3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Create(::core::mem::transmute_copy(&istransactional), ::core::mem::transmute_copy(&isworldreadable)).into() @@ -6666,7 +6742,7 @@ impl IMSMQQueueInfo3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Security, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Security, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Security() { @@ -6677,7 +6753,7 @@ impl IMSMQQueueInfo3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSecurity(::core::mem::transmute(&varsecurity)).into() @@ -6778,8 +6854,8 @@ impl IMSMQQueueInfo3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfo4_Impl: Sized + super::Com::IDispatch_Impl { fn QueueGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ServiceTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6799,31 +6875,31 @@ pub trait IMSMQQueueInfo4_Impl: Sized + super::Com::IDispatch_Impl { fn SetQuota(&self, lquota: i32) -> ::windows_core::Result<()>; fn BasePriority(&self) -> ::windows_core::Result; fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()>; - fn CreateTime(&self) -> ::windows_core::Result; - fn ModifyTime(&self) -> ::windows_core::Result; + fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Authenticate(&self) -> ::windows_core::Result; fn SetAuthenticate(&self, lauthenticate: i32) -> ::windows_core::Result<()>; fn JournalQuota(&self) -> ::windows_core::Result; fn SetJournalQuota(&self, ljournalquota: i32) -> ::windows_core::Result<()>; fn IsWorldReadable(&self) -> ::windows_core::Result; - fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Delete(&self) -> ::windows_core::Result<()>; fn Open(&self, access: i32, sharemode: i32) -> ::windows_core::Result; fn Refresh(&self) -> ::windows_core::Result<()>; fn Update(&self) -> ::windows_core::Result<()>; fn PathNameDNS(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Properties(&self) -> ::windows_core::Result; - fn Security(&self) -> ::windows_core::Result; - fn SetSecurity(&self, varsecurity: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSecurity(&self, varsecurity: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn IsTransactional2(&self) -> ::windows_core::Result; fn IsWorldReadable2(&self) -> ::windows_core::Result; fn MulticastAddress(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetMulticastAddress(&self, bstrmulticastaddress: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ADsPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfo4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfo4_Vtbl { pub const fn new, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>() -> IMSMQQueueInfo4_Vtbl { unsafe extern "system" fn QueueGuid, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrguidqueue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6976,7 +7052,7 @@ impl IMSMQQueueInfo4_Vtbl { let this = (*this).get_impl(); this.SetBasePriority(::core::mem::transmute_copy(&lbasepriority)).into() } - unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateTime, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateTime() { @@ -6987,7 +7063,7 @@ impl IMSMQQueueInfo4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ModifyTime, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ModifyTime() { @@ -7041,7 +7117,7 @@ impl IMSMQQueueInfo4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Create(::core::mem::transmute_copy(&istransactional), ::core::mem::transmute_copy(&isworldreadable)).into() @@ -7094,7 +7170,7 @@ impl IMSMQQueueInfo4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Security, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Security, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Security() { @@ -7105,7 +7181,7 @@ impl IMSMQQueueInfo4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSecurity, Impl: IMSMQQueueInfo4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSecurity(::core::mem::transmute(&varsecurity)).into() @@ -7206,15 +7282,15 @@ impl IMSMQQueueInfo4_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfos_Impl: Sized + super::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Next(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfos {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfos_Vtbl { pub const fn new, Impl: IMSMQQueueInfos_Impl, const OFFSET: isize>() -> IMSMQQueueInfos_Vtbl { unsafe extern "system" fn Reset, Impl: IMSMQQueueInfos_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7243,16 +7319,16 @@ impl IMSMQQueueInfos_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfos2_Impl: Sized + super::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Next(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfos2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfos2_Vtbl { pub const fn new, Impl: IMSMQQueueInfos2_Impl, const OFFSET: isize>() -> IMSMQQueueInfos2_Vtbl { unsafe extern "system" fn Reset, Impl: IMSMQQueueInfos2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7293,16 +7369,16 @@ impl IMSMQQueueInfos2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfos3_Impl: Sized + super::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Next(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfos3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfos3_Vtbl { pub const fn new, Impl: IMSMQQueueInfos3_Impl, const OFFSET: isize>() -> IMSMQQueueInfos3_Vtbl { unsafe extern "system" fn Reset, Impl: IMSMQQueueInfos3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7343,16 +7419,16 @@ impl IMSMQQueueInfos3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueInfos4_Impl: Sized + super::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Next(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueInfos4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueInfos4_Vtbl { pub const fn new, Impl: IMSMQQueueInfos4_Impl, const OFFSET: isize>() -> IMSMQQueueInfos4_Vtbl { unsafe extern "system" fn Reset, Impl: IMSMQQueueInfos4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7393,16 +7469,16 @@ impl IMSMQQueueInfos4_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQQueueManagement_Impl: Sized + IMSMQManagement_Impl { fn JournalMessageCount(&self) -> ::windows_core::Result; - fn BytesInJournal(&self) -> ::windows_core::Result; - fn EodGetReceiveInfo(&self) -> ::windows_core::Result; + fn BytesInJournal(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn EodGetReceiveInfo(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQQueueManagement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQQueueManagement_Vtbl { pub const fn new, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>() -> IMSMQQueueManagement_Vtbl { unsafe extern "system" fn JournalMessageCount, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pljournalmessagecount: *mut i32) -> ::windows_core::HRESULT { @@ -7416,7 +7492,7 @@ impl IMSMQQueueManagement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BytesInJournal, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinjournal: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BytesInJournal, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvbytesinjournal: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BytesInJournal() { @@ -7427,7 +7503,7 @@ impl IMSMQQueueManagement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn EodGetReceiveInfo, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvcollection: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EodGetReceiveInfo, Impl: IMSMQQueueManagement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvcollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EodGetReceiveInfo() { @@ -7449,16 +7525,16 @@ impl IMSMQQueueManagement_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransaction_Impl: Sized + super::Com::IDispatch_Impl { fn Transaction(&self) -> ::windows_core::Result; - fn Commit(&self, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Abort(&self, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Commit(&self, fretaining: *const ::windows_core::VARIANT, grftc: *const ::windows_core::VARIANT, grfrm: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Abort(&self, fretaining: *const ::windows_core::VARIANT, fasync: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransaction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransaction_Vtbl { pub const fn new, Impl: IMSMQTransaction_Impl, const OFFSET: isize>() -> IMSMQTransaction_Vtbl { unsafe extern "system" fn Transaction, Impl: IMSMQTransaction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pltransaction: *mut i32) -> ::windows_core::HRESULT { @@ -7472,12 +7548,12 @@ impl IMSMQTransaction_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Commit, Impl: IMSMQTransaction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Commit, Impl: IMSMQTransaction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fretaining: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, grftc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, grfrm: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Commit(::core::mem::transmute_copy(&fretaining), ::core::mem::transmute_copy(&grftc), ::core::mem::transmute_copy(&grfrm)).into() } - unsafe extern "system" fn Abort, Impl: IMSMQTransaction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Abort, Impl: IMSMQTransaction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fretaining: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, fasync: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Abort(::core::mem::transmute_copy(&fretaining), ::core::mem::transmute_copy(&fasync)).into() @@ -7493,18 +7569,18 @@ impl IMSMQTransaction_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransaction2_Impl: Sized + IMSMQTransaction_Impl { - fn InitNew(&self, vartransaction: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn InitNew(&self, vartransaction: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransaction2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransaction2_Vtbl { pub const fn new, Impl: IMSMQTransaction2_Impl, const OFFSET: isize>() -> IMSMQTransaction2_Vtbl { - unsafe extern "system" fn InitNew, Impl: IMSMQTransaction2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartransaction: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InitNew, Impl: IMSMQTransaction2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vartransaction: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InitNew(::core::mem::transmute(&vartransaction)).into() @@ -7530,17 +7606,17 @@ impl IMSMQTransaction2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransaction3_Impl: Sized + IMSMQTransaction2_Impl { - fn ITransaction(&self) -> ::windows_core::Result; + fn ITransaction(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransaction3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransaction3_Vtbl { pub const fn new, Impl: IMSMQTransaction3_Impl, const OFFSET: isize>() -> IMSMQTransaction3_Vtbl { - unsafe extern "system" fn ITransaction, Impl: IMSMQTransaction3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaritransaction: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ITransaction, Impl: IMSMQTransaction3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaritransaction: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ITransaction() { @@ -7557,14 +7633,14 @@ impl IMSMQTransaction3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransactionDispenser_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransactionDispenser {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransactionDispenser_Vtbl { pub const fn new, Impl: IMSMQTransactionDispenser_Impl, const OFFSET: isize>() -> IMSMQTransactionDispenser_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQTransactionDispenser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7584,15 +7660,15 @@ impl IMSMQTransactionDispenser_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransactionDispenser2_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransactionDispenser2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransactionDispenser2_Vtbl { pub const fn new, Impl: IMSMQTransactionDispenser2_Impl, const OFFSET: isize>() -> IMSMQTransactionDispenser2_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQTransactionDispenser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7627,15 +7703,15 @@ impl IMSMQTransactionDispenser2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMSMQTransactionDispenser3_Impl: Sized + super::Com::IDispatch_Impl { fn BeginTransaction(&self) -> ::windows_core::Result; fn Properties(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMSMQTransactionDispenser3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMSMQTransactionDispenser3_Vtbl { pub const fn new, Impl: IMSMQTransactionDispenser3_Impl, const OFFSET: isize>() -> IMSMQTransactionDispenser3_Vtbl { unsafe extern "system" fn BeginTransaction, Impl: IMSMQTransactionDispenser3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptransaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -7670,12 +7746,12 @@ impl IMSMQTransactionDispenser3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _DMSMQEventEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _DMSMQEventEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _DMSMQEventEvents_Vtbl { pub const fn new, Impl: _DMSMQEventEvents_Impl, const OFFSET: isize>() -> _DMSMQEventEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/mod.rs b/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/mod.rs index 0c569001a9..a30c0b806b 100644 --- a/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/MessageQueuing/mod.rs @@ -33,8 +33,8 @@ pub unsafe fn MQCreateCursor(hqueue: isize) -> ::windows_core::Result(psecuritydescriptor: P0, pqueueprops: *mut MQQUEUEPROPS, lpwcsformatname: ::windows_core::PWSTR, lpdwformatnamelength: *mut u32) -> ::windows_core::Result<()> where @@ -64,8 +64,6 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQFreeSecurityContext(hsecuritycontext : super::super::Foundation:: HANDLE)); MQFreeSecurityContext(hsecuritycontext.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQGetMachineProperties(lpwcsmachinename: P0, pguidmachineid: ::core::option::Option<*const ::windows_core::GUID>, pqmprops: *mut MQQMPROPS) -> ::windows_core::Result<()> where @@ -81,8 +79,6 @@ pub unsafe fn MQGetOverlappedResult(lpoverlapped: *const super::IO::OVERLAPPED) ::windows_targets::link!("mqrt.dll" "system" fn MQGetOverlappedResult(lpoverlapped : *const super::IO:: OVERLAPPED) -> ::windows_core::HRESULT); MQGetOverlappedResult(lpoverlapped).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQGetPrivateComputerInformation(lpwcscomputername: P0, pprivateprops: *mut MQPRIVATEPROPS) -> ::windows_core::Result<()> where @@ -91,8 +87,6 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQGetPrivateComputerInformation(lpwcscomputername : ::windows_core::PCWSTR, pprivateprops : *mut MQPRIVATEPROPS) -> ::windows_core::HRESULT); MQGetPrivateComputerInformation(lpwcscomputername.into_param().abi(), pprivateprops).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQGetQueueProperties(lpwcsformatname: P0, pqueueprops: *mut MQQUEUEPROPS) -> ::windows_core::Result<()> where @@ -133,8 +127,6 @@ pub unsafe fn MQInstanceToFormatName(pguid: *const ::windows_core::GUID, lpwcsfo ::windows_targets::link!("mqrt.dll" "system" fn MQInstanceToFormatName(pguid : *const ::windows_core::GUID, lpwcsformatname : ::windows_core::PWSTR, lpdwformatnamelength : *mut u32) -> ::windows_core::HRESULT); MQInstanceToFormatName(pguid, ::core::mem::transmute(lpwcsformatname), lpdwformatnamelength).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQLocateBegin(lpwcscontext: P0, prestriction: ::core::option::Option<*const MQRESTRICTION>, pcolumns: *const MQCOLUMNSET, psort: *const MQSORTSET) -> ::windows_core::Result where @@ -152,15 +144,13 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQLocateEnd(henum : super::super::Foundation:: HANDLE) -> ::windows_core::HRESULT); MQLocateEnd(henum.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn MQLocateNext(henum: P0, pcprops: *mut u32, apropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> +pub unsafe fn MQLocateNext(henum: P0, pcprops: *mut u32, apropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("mqrt.dll" "system" fn MQLocateNext(henum : super::super::Foundation:: HANDLE, pcprops : *mut u32, apropvar : *mut super::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - MQLocateNext(henum.into_param().abi(), pcprops, apropvar).ok() + ::windows_targets::link!("mqrt.dll" "system" fn MQLocateNext(henum : super::super::Foundation:: HANDLE, pcprops : *mut u32, apropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + MQLocateNext(henum.into_param().abi(), pcprops, ::core::mem::transmute(apropvar)).ok() } #[inline] pub unsafe fn MQMarkMessageRejected(hqueue: P0, ulllookupid: u64) -> ::windows_core::Result<()> @@ -180,8 +170,6 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQMgmtAction(pcomputername : ::windows_core::PCWSTR, pobjectname : ::windows_core::PCWSTR, paction : ::windows_core::PCWSTR) -> ::windows_core::HRESULT); MQMgmtAction(pcomputername.into_param().abi(), pobjectname.into_param().abi(), paction.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQMgmtGetInfo(pcomputername: P0, pobjectname: P1, pmgmtprops: *mut MQMGMTPROPS) -> ::windows_core::Result<()> where @@ -223,8 +211,8 @@ pub unsafe fn MQPurgeQueue(hqueue: isize) -> ::windows_core::Result<()> { ::windows_targets::link!("mqrt.dll" "system" fn MQPurgeQueue(hqueue : isize) -> ::windows_core::HRESULT); MQPurgeQueue(hqueue).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_DistributedTransactionCoordinator\"`, `\"Win32_System_IO\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_DistributedTransactionCoordinator", feature = "Win32_System_IO", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_DistributedTransactionCoordinator\"`, `\"Win32_System_IO\"`"] +#[cfg(all(feature = "Win32_System_DistributedTransactionCoordinator", feature = "Win32_System_IO"))] #[inline] pub unsafe fn MQReceiveMessage(hsource: isize, dwtimeout: u32, dwaction: u32, pmessageprops: ::core::option::Option<*mut MQMSGPROPS>, lpoverlapped: ::core::option::Option<*mut super::IO::OVERLAPPED>, fnreceivecallback: PMQRECEIVECALLBACK, hcursor: P0, ptransaction: P1) -> ::windows_core::Result<()> where @@ -234,8 +222,8 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQReceiveMessage(hsource : isize, dwtimeout : u32, dwaction : u32, pmessageprops : *mut MQMSGPROPS, lpoverlapped : *mut super::IO:: OVERLAPPED, fnreceivecallback : PMQRECEIVECALLBACK, hcursor : super::super::Foundation:: HANDLE, ptransaction : * mut::core::ffi::c_void) -> ::windows_core::HRESULT); MQReceiveMessage(hsource, dwtimeout, dwaction, ::core::mem::transmute(pmessageprops.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(lpoverlapped.unwrap_or(::std::ptr::null_mut())), fnreceivecallback, hcursor.into_param().abi(), ptransaction.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_DistributedTransactionCoordinator\"`, `\"Win32_System_IO\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_DistributedTransactionCoordinator", feature = "Win32_System_IO", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_DistributedTransactionCoordinator\"`, `\"Win32_System_IO\"`"] +#[cfg(all(feature = "Win32_System_DistributedTransactionCoordinator", feature = "Win32_System_IO"))] #[inline] pub unsafe fn MQReceiveMessageByLookupId(hsource: isize, ulllookupid: u64, dwlookupaction: u32, pmessageprops: ::core::option::Option<*mut MQMSGPROPS>, lpoverlapped: ::core::option::Option<*mut super::IO::OVERLAPPED>, fnreceivecallback: PMQRECEIVECALLBACK, ptransaction: P0) -> ::windows_core::Result<()> where @@ -249,8 +237,8 @@ pub unsafe fn MQRegisterCertificate(dwflags: u32, lpcertbuffer: *const ::core::f ::windows_targets::link!("mqrt.dll" "system" fn MQRegisterCertificate(dwflags : u32, lpcertbuffer : *const ::core::ffi::c_void, dwcertbufferlength : u32) -> ::windows_core::HRESULT); MQRegisterCertificate(dwflags, lpcertbuffer, dwcertbufferlength).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_DistributedTransactionCoordinator\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_DistributedTransactionCoordinator", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_DistributedTransactionCoordinator\"`"] +#[cfg(feature = "Win32_System_DistributedTransactionCoordinator")] #[inline] pub unsafe fn MQSendMessage(hdestinationqueue: isize, pmessageprops: *const MQMSGPROPS, ptransaction: P0) -> ::windows_core::Result<()> where @@ -259,8 +247,6 @@ where ::windows_targets::link!("mqrt.dll" "system" fn MQSendMessage(hdestinationqueue : isize, pmessageprops : *const MQMSGPROPS, ptransaction : * mut::core::ffi::c_void) -> ::windows_core::HRESULT); MQSendMessage(hdestinationqueue, pmessageprops, ptransaction.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn MQSetQueueProperties(lpwcsformatname: P0, pqueueprops: *mut MQQUEUEPROPS) -> ::windows_core::Result<()> where @@ -324,10 +310,8 @@ impl IMSMQApplication2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MachineIdOfMachineName)(::windows_core::Interface::as_raw(self), machinename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterCertificate(&self, flags: *const super::Variant::VARIANT, externalcertificate: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RegisterCertificate)(::windows_core::Interface::as_raw(self), flags, externalcertificate).ok() + pub unsafe fn RegisterCertificate(&self, flags: *const ::windows_core::VARIANT, externalcertificate: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).RegisterCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(flags), ::core::mem::transmute(externalcertificate)).ok() } pub unsafe fn MachineNameOfMachineId(&self, bstrguid: P0) -> ::windows_core::Result<::windows_core::BSTR> where @@ -364,10 +348,7 @@ impl IMSMQApplication2 { #[doc(hidden)] pub struct IMSMQApplication2_Vtbl { pub base__: IMSMQApplication_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: *const super::Variant::VARIANT, externalcertificate: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RegisterCertificate: usize, + pub RegisterCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, externalcertificate: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MachineNameOfMachineId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguid: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrmachinename: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub MSMQVersionMajor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psmsmqversionmajor: *mut i16) -> ::windows_core::HRESULT, pub MSMQVersionMinor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psmsmqversionminor: *mut i16) -> ::windows_core::HRESULT, @@ -396,10 +377,8 @@ impl IMSMQApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.MachineIdOfMachineName)(::windows_core::Interface::as_raw(self), machinename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterCertificate(&self, flags: *const super::Variant::VARIANT, externalcertificate: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.RegisterCertificate)(::windows_core::Interface::as_raw(self), flags, externalcertificate).ok() + pub unsafe fn RegisterCertificate(&self, flags: *const ::windows_core::VARIANT, externalcertificate: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.RegisterCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(flags), ::core::mem::transmute(externalcertificate)).ok() } pub unsafe fn MachineNameOfMachineId(&self, bstrguid: P0) -> ::windows_core::Result<::windows_core::BSTR> where @@ -430,15 +409,11 @@ impl IMSMQApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ActiveQueues(&self) -> ::windows_core::Result { + pub unsafe fn ActiveQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ActiveQueues)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PrivateQueues(&self) -> ::windows_core::Result { + pub unsafe fn PrivateQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PrivateQueues)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -450,9 +425,7 @@ impl IMSMQApplication3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsConnected)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BytesInAllQueues(&self) -> ::windows_core::Result { + pub unsafe fn BytesInAllQueues(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BytesInAllQueues)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -481,20 +454,11 @@ impl IMSMQApplication3 { #[doc(hidden)] pub struct IMSMQApplication3_Vtbl { pub base__: IMSMQApplication2_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ActiveQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvactivequeues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ActiveQueues: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PrivateQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvprivatequeues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PrivateQueues: usize, + pub ActiveQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvactivequeues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PrivateQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvprivatequeues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DirectoryServiceServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrdirectoryserviceserver: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsConnected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfisconnected: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BytesInAllQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinallqueues: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BytesInAllQueues: usize, + pub BytesInAllQueues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinallqueues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetMachine: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmachine: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Machine: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Connect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -512,11 +476,9 @@ pub struct IMSMQApplication3_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQCollection, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQCollection { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn Item(&self, index: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -532,10 +494,7 @@ impl IMSMQCollection { #[doc(hidden)] pub struct IMSMQCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: *const super::Variant::VARIANT, pvarret: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Item: usize, + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarret: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -844,10 +803,8 @@ pub struct IMSMQEvent3_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQManagement, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQManagement { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Init(&self, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Init)(::windows_core::Interface::as_raw(self), machine, pathname, formatname).ok() + pub unsafe fn Init(&self, machine: *const ::windows_core::VARIANT, pathname: *const ::windows_core::VARIANT, formatname: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Init)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(machine), ::core::mem::transmute(pathname), ::core::mem::transmute(formatname)).ok() } pub unsafe fn FormatName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -877,9 +834,7 @@ impl IMSMQManagement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionalStatus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result { + pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BytesInQueue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -889,10 +844,7 @@ impl IMSMQManagement { #[doc(hidden)] pub struct IMSMQManagement_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Init: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Init: usize, + pub Init: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, machine: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pathname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, formatname: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub FormatName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrformatname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Machine: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub MessageCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plmessagecount: *mut i32) -> ::windows_core::HRESULT, @@ -900,10 +852,7 @@ pub struct IMSMQManagement_Vtbl { pub QueueType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plqueuetype: *mut i32) -> ::windows_core::HRESULT, pub IsLocal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfislocal: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub TransactionalStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pltransactionalstatus: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BytesInQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinqueue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BytesInQueue: usize, + pub BytesInQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinqueue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -995,16 +944,15 @@ impl IMSMQMessage { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BodyLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Body(&self) -> ::windows_core::Result { + pub unsafe fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Body)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBody(&self, varbody: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn SetBody(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1020,22 +968,19 @@ impl IMSMQMessage { { (::windows_core::Interface::vtable(self).putref_AdminQueueInfo)(::windows_core::Interface::as_raw(self), pqinfoadmin.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Id(&self) -> ::windows_core::Result { + pub unsafe fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CorrelationId(&self) -> ::windows_core::Result { + pub unsafe fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CorrelationId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCorrelationId(&self, varmsgid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varmsgid)).ok() + pub unsafe fn SetCorrelationId(&self, varmsgid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), varmsgid.into_param().abi()).ok() } pub unsafe fn Ack(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1082,15 +1027,11 @@ impl IMSMQMessage { pub unsafe fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetEncryptAlgorithm)(::windows_core::Interface::as_raw(self), lencryptalg).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SentTime(&self) -> ::windows_core::Result { + pub unsafe fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SentTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result { + pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ArrivedTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1100,20 +1041,17 @@ impl IMSMQMessage { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result { + pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderCertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderCertificate(&self, varsendercert: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsendercert)).ok() + pub unsafe fn SetSenderCertificate(&self, varsendercert: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), varsendercert.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderId(&self) -> ::windows_core::Result { + pub unsafe fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1124,13 +1062,13 @@ impl IMSMQMessage { pub unsafe fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSenderIdType)(::windows_core::Interface::as_raw(self), lsenderidtype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), transaction).ok() + (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), ::core::mem::transmute(transaction)).ok() } pub unsafe fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AttachCurrentSecurityContext)(::windows_core::Interface::as_raw(self)).ok() @@ -1167,14 +1105,8 @@ pub struct IMSMQMessage_Vtbl { pub SetAppSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lappspecific: i32) -> ::windows_core::HRESULT, pub SourceMachineGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidsrcmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BodyLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbbody: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Body: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBody: usize, + pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AdminQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoadmin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -1183,18 +1115,9 @@ pub struct IMSMQMessage_Vtbl { pub putref_AdminQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqinfoadmin: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_AdminQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Id: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CorrelationId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCorrelationId: usize, + pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Ack: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plack: *mut i32) -> ::windows_core::HRESULT, pub SetAck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lack: i32) -> ::windows_core::HRESULT, pub Label: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrlabel: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1207,35 +1130,20 @@ pub struct IMSMQMessage_Vtbl { pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lhashalg: i32) -> ::windows_core::HRESULT, pub EncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plencryptalg: *mut i32) -> ::windows_core::HRESULT, pub SetEncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lencryptalg: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SentTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ArrivedTime: usize, + pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub DestinationQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfodest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DestinationQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderId: usize, + pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderidtype: *mut i32) -> ::windows_core::HRESULT, pub SetSenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsenderidtype: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Send: usize, pub AttachCurrentSecurityContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -1329,16 +1237,15 @@ impl IMSMQMessage2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BodyLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Body(&self) -> ::windows_core::Result { + pub unsafe fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Body)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBody(&self, varbody: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn SetBody(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1354,22 +1261,19 @@ impl IMSMQMessage2 { { (::windows_core::Interface::vtable(self).putref_AdminQueueInfo_v1)(::windows_core::Interface::as_raw(self), pqinfoadmin.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Id(&self) -> ::windows_core::Result { + pub unsafe fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CorrelationId(&self) -> ::windows_core::Result { + pub unsafe fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CorrelationId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCorrelationId(&self, varmsgid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varmsgid)).ok() + pub unsafe fn SetCorrelationId(&self, varmsgid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), varmsgid.into_param().abi()).ok() } pub unsafe fn Ack(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1416,15 +1320,11 @@ impl IMSMQMessage2 { pub unsafe fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetEncryptAlgorithm)(::windows_core::Interface::as_raw(self), lencryptalg).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SentTime(&self) -> ::windows_core::Result { + pub unsafe fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SentTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result { + pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ArrivedTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1434,20 +1334,17 @@ impl IMSMQMessage2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result { + pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderCertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderCertificate(&self, varsendercert: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsendercert)).ok() + pub unsafe fn SetSenderCertificate(&self, varsendercert: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), varsendercert.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderId(&self) -> ::windows_core::Result { + pub unsafe fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1458,13 +1355,13 @@ impl IMSMQMessage2 { pub unsafe fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSenderIdType)(::windows_core::Interface::as_raw(self), lsenderidtype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), transaction).ok() + (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), ::core::mem::transmute(transaction)).ok() } pub unsafe fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AttachCurrentSecurityContext)(::windows_core::Interface::as_raw(self)).ok() @@ -1473,16 +1370,15 @@ impl IMSMQMessage2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderVersion)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Extension(&self) -> ::windows_core::Result { + pub unsafe fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Extension)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtension(&self, varextension: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varextension)).ok() + pub unsafe fn SetExtension(&self, varextension: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), varextension.into_param().abi()).ok() } pub unsafe fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -1500,27 +1396,25 @@ impl IMSMQMessage2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionStatusQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result { + pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationSymmetricKey)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardestsymmkey)).ok() + pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), vardestsymmkey.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Signature(&self) -> ::windows_core::Result { + pub unsafe fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Signature)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSignature(&self, varsignature: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsignature)).ok() + pub unsafe fn SetSignature(&self, varsignature: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), varsignature.into_param().abi()).ok() } pub unsafe fn AuthenticationProviderType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1539,10 +1433,11 @@ impl IMSMQMessage2 { { (::windows_core::Interface::vtable(self).SetAuthenticationProviderName)(::windows_core::Interface::as_raw(self), bstrauthprovname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderId(&self, varsenderid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsenderid)).ok() + pub unsafe fn SetSenderId(&self, varsenderid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), varsenderid.into_param().abi()).ok() } pub unsafe fn MsgClass(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1557,9 +1452,7 @@ impl IMSMQMessage2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TransactionId(&self) -> ::windows_core::Result { + pub unsafe fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1635,14 +1528,8 @@ pub struct IMSMQMessage2_Vtbl { pub SetAppSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lappspecific: i32) -> ::windows_core::HRESULT, pub SourceMachineGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidsrcmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BodyLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbbody: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Body: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBody: usize, + pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoadmin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -1651,18 +1538,9 @@ pub struct IMSMQMessage2_Vtbl { pub putref_AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqinfoadmin: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_AdminQueueInfo_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Id: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CorrelationId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCorrelationId: usize, + pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Ack: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plack: *mut i32) -> ::windows_core::HRESULT, pub SetAck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lack: i32) -> ::windows_core::HRESULT, pub Label: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrlabel: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1675,86 +1553,47 @@ pub struct IMSMQMessage2_Vtbl { pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lhashalg: i32) -> ::windows_core::HRESULT, pub EncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plencryptalg: *mut i32) -> ::windows_core::HRESULT, pub SetEncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lencryptalg: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SentTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ArrivedTime: usize, + pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub DestinationQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfodest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DestinationQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderId: usize, + pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderidtype: *mut i32) -> ::windows_core::HRESULT, pub SetSenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsenderidtype: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Send: usize, pub AttachCurrentSecurityContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SenderVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderversion: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Extension: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtension: usize, + pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidconnectortype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguidconnectortype: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub TransactionStatusQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoxactstatus: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] TransactionStatusQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Signature: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSignature: usize, + pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthprovtype: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthprovtype: i32) -> ::windows_core::HRESULT, pub AuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrauthprovname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetAuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrauthprovname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderId: usize, + pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plmsgclass: *mut i32) -> ::windows_core::HRESULT, pub SetMsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lmsgclass: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TransactionId: usize, + pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsFirstInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisfirstinxact: *mut i16) -> ::windows_core::HRESULT, pub IsLastInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pislastinxact: *mut i16) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -1865,16 +1704,15 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BodyLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Body(&self) -> ::windows_core::Result { + pub unsafe fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Body)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBody(&self, varbody: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn SetBody(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1890,22 +1728,19 @@ impl IMSMQMessage3 { { (::windows_core::Interface::vtable(self).putref_AdminQueueInfo_v1)(::windows_core::Interface::as_raw(self), pqinfoadmin.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Id(&self) -> ::windows_core::Result { + pub unsafe fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CorrelationId(&self) -> ::windows_core::Result { + pub unsafe fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CorrelationId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCorrelationId(&self, varmsgid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varmsgid)).ok() + pub unsafe fn SetCorrelationId(&self, varmsgid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), varmsgid.into_param().abi()).ok() } pub unsafe fn Ack(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1952,15 +1787,11 @@ impl IMSMQMessage3 { pub unsafe fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetEncryptAlgorithm)(::windows_core::Interface::as_raw(self), lencryptalg).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SentTime(&self) -> ::windows_core::Result { + pub unsafe fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SentTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result { + pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ArrivedTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1970,20 +1801,17 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result { + pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderCertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderCertificate(&self, varsendercert: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsendercert)).ok() + pub unsafe fn SetSenderCertificate(&self, varsendercert: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), varsendercert.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderId(&self) -> ::windows_core::Result { + pub unsafe fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1994,13 +1822,13 @@ impl IMSMQMessage3 { pub unsafe fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSenderIdType)(::windows_core::Interface::as_raw(self), lsenderidtype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), transaction).ok() + (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), ::core::mem::transmute(transaction)).ok() } pub unsafe fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AttachCurrentSecurityContext)(::windows_core::Interface::as_raw(self)).ok() @@ -2009,16 +1837,15 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderVersion)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Extension(&self) -> ::windows_core::Result { + pub unsafe fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Extension)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtension(&self, varextension: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varextension)).ok() + pub unsafe fn SetExtension(&self, varextension: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), varextension.into_param().abi()).ok() } pub unsafe fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2036,27 +1863,25 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionStatusQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result { + pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationSymmetricKey)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardestsymmkey)).ok() + pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), vardestsymmkey.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Signature(&self) -> ::windows_core::Result { + pub unsafe fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Signature)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSignature(&self, varsignature: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsignature)).ok() + pub unsafe fn SetSignature(&self, varsignature: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), varsignature.into_param().abi()).ok() } pub unsafe fn AuthenticationProviderType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2075,10 +1900,11 @@ impl IMSMQMessage3 { { (::windows_core::Interface::vtable(self).SetAuthenticationProviderName)(::windows_core::Interface::as_raw(self), bstrauthprovname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderId(&self, varsenderid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsenderid)).ok() + pub unsafe fn SetSenderId(&self, varsenderid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), varsenderid.into_param().abi()).ok() } pub unsafe fn MsgClass(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2093,9 +1919,7 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TransactionId(&self) -> ::windows_core::Result { + pub unsafe fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2187,9 +2011,7 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Destination)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupId(&self) -> ::windows_core::Result { + pub unsafe fn LookupId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LookupId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2212,9 +2034,7 @@ impl IMSMQMessage3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SoapEnvelope)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CompoundMessage(&self) -> ::windows_core::Result { + pub unsafe fn CompoundMessage(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CompoundMessage)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2262,14 +2082,8 @@ pub struct IMSMQMessage3_Vtbl { pub SetAppSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lappspecific: i32) -> ::windows_core::HRESULT, pub SourceMachineGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidsrcmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BodyLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbbody: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Body: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBody: usize, + pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoadmin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2278,18 +2092,9 @@ pub struct IMSMQMessage3_Vtbl { pub putref_AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqinfoadmin: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_AdminQueueInfo_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Id: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CorrelationId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCorrelationId: usize, + pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Ack: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plack: *mut i32) -> ::windows_core::HRESULT, pub SetAck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lack: i32) -> ::windows_core::HRESULT, pub Label: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrlabel: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -2302,86 +2107,47 @@ pub struct IMSMQMessage3_Vtbl { pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lhashalg: i32) -> ::windows_core::HRESULT, pub EncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plencryptalg: *mut i32) -> ::windows_core::HRESULT, pub SetEncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lencryptalg: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SentTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ArrivedTime: usize, + pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub DestinationQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfodest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DestinationQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderId: usize, + pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderidtype: *mut i32) -> ::windows_core::HRESULT, pub SetSenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsenderidtype: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Send: usize, pub AttachCurrentSecurityContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SenderVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderversion: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Extension: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtension: usize, + pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidconnectortype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguidconnectortype: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub TransactionStatusQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoxactstatus: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] TransactionStatusQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Signature: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSignature: usize, + pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthprovtype: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthprovtype: i32) -> ::windows_core::HRESULT, pub AuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrauthprovname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetAuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrauthprovname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderId: usize, + pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plmsgclass: *mut i32) -> ::windows_core::HRESULT, pub SetMsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lmsgclass: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TransactionId: usize, + pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsFirstInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisfirstinxact: *mut i16) -> ::windows_core::HRESULT, pub IsLastInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pislastinxact: *mut i16) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -2429,19 +2195,13 @@ pub struct IMSMQMessage3_Vtbl { pub Destination: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppdestdestination: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Destination: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlookupid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LookupId: usize, + pub LookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlookupid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsAuthenticated2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisauthenticated: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsFirstInTransaction2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisfirstinxact: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsLastInTransaction2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pislastinxact: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub AttachCurrentSecurityContext2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SoapEnvelope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsoapenvelope: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CompoundMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CompoundMessage: usize, + pub CompoundMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetSoapHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsoapheader: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSoapBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsoapbody: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -2535,16 +2295,15 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BodyLength)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Body(&self) -> ::windows_core::Result { + pub unsafe fn Body(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Body)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetBody(&self, varbody: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varbody)).ok() + pub unsafe fn SetBody(&self, varbody: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetBody)(::windows_core::Interface::as_raw(self), varbody.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2560,22 +2319,19 @@ impl IMSMQMessage4 { { (::windows_core::Interface::vtable(self).putref_AdminQueueInfo_v1)(::windows_core::Interface::as_raw(self), pqinfoadmin.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Id(&self) -> ::windows_core::Result { + pub unsafe fn Id(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CorrelationId(&self) -> ::windows_core::Result { + pub unsafe fn CorrelationId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CorrelationId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetCorrelationId(&self, varmsgid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varmsgid)).ok() + pub unsafe fn SetCorrelationId(&self, varmsgid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetCorrelationId)(::windows_core::Interface::as_raw(self), varmsgid.into_param().abi()).ok() } pub unsafe fn Ack(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2622,15 +2378,11 @@ impl IMSMQMessage4 { pub unsafe fn SetEncryptAlgorithm(&self, lencryptalg: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetEncryptAlgorithm)(::windows_core::Interface::as_raw(self), lencryptalg).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SentTime(&self) -> ::windows_core::Result { + pub unsafe fn SentTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SentTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result { + pub unsafe fn ArrivedTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ArrivedTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2640,20 +2392,17 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result { + pub unsafe fn SenderCertificate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderCertificate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderCertificate(&self, varsendercert: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsendercert)).ok() + pub unsafe fn SetSenderCertificate(&self, varsendercert: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderCertificate)(::windows_core::Interface::as_raw(self), varsendercert.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SenderId(&self) -> ::windows_core::Result { + pub unsafe fn SenderId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2664,13 +2413,13 @@ impl IMSMQMessage4 { pub unsafe fn SetSenderIdType(&self, lsenderidtype: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSenderIdType)(::windows_core::Interface::as_raw(self), lsenderidtype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Send(&self, destinationqueue: P0, transaction: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), transaction).ok() + (::windows_core::Interface::vtable(self).Send)(::windows_core::Interface::as_raw(self), destinationqueue.into_param().abi(), ::core::mem::transmute(transaction)).ok() } pub unsafe fn AttachCurrentSecurityContext(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AttachCurrentSecurityContext)(::windows_core::Interface::as_raw(self)).ok() @@ -2679,16 +2428,15 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SenderVersion)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Extension(&self) -> ::windows_core::Result { + pub unsafe fn Extension(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Extension)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetExtension(&self, varextension: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varextension)).ok() + pub unsafe fn SetExtension(&self, varextension: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetExtension)(::windows_core::Interface::as_raw(self), varextension.into_param().abi()).ok() } pub unsafe fn ConnectorTypeGuid(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2706,27 +2454,25 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionStatusQueueInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result { + pub unsafe fn DestinationSymmetricKey(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DestinationSymmetricKey)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vardestsymmkey)).ok() + pub unsafe fn SetDestinationSymmetricKey(&self, vardestsymmkey: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDestinationSymmetricKey)(::windows_core::Interface::as_raw(self), vardestsymmkey.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Signature(&self) -> ::windows_core::Result { + pub unsafe fn Signature(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Signature)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSignature(&self, varsignature: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsignature)).ok() + pub unsafe fn SetSignature(&self, varsignature: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSignature)(::windows_core::Interface::as_raw(self), varsignature.into_param().abi()).ok() } pub unsafe fn AuthenticationProviderType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2745,10 +2491,11 @@ impl IMSMQMessage4 { { (::windows_core::Interface::vtable(self).SetAuthenticationProviderName)(::windows_core::Interface::as_raw(self), bstrauthprovname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSenderId(&self, varsenderid: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsenderid)).ok() + pub unsafe fn SetSenderId(&self, varsenderid: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSenderId)(::windows_core::Interface::as_raw(self), varsenderid.into_param().abi()).ok() } pub unsafe fn MsgClass(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2763,9 +2510,7 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TransactionId(&self) -> ::windows_core::Result { + pub unsafe fn TransactionId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).TransactionId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2857,9 +2602,7 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Destination)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupId(&self) -> ::windows_core::Result { + pub unsafe fn LookupId(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LookupId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2882,9 +2625,7 @@ impl IMSMQMessage4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SoapEnvelope)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CompoundMessage(&self) -> ::windows_core::Result { + pub unsafe fn CompoundMessage(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CompoundMessage)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2932,14 +2673,8 @@ pub struct IMSMQMessage4_Vtbl { pub SetAppSpecific: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lappspecific: i32) -> ::windows_core::HRESULT, pub SourceMachineGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidsrcmachine: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub BodyLength: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcbbody: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Body: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetBody: usize, + pub Body: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarbody: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varbody: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoadmin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2948,18 +2683,9 @@ pub struct IMSMQMessage4_Vtbl { pub putref_AdminQueueInfo_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pqinfoadmin: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] putref_AdminQueueInfo_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Id: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CorrelationId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetCorrelationId: usize, + pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmsgid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetCorrelationId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varmsgid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Ack: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plack: *mut i32) -> ::windows_core::HRESULT, pub SetAck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lack: i32) -> ::windows_core::HRESULT, pub Label: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrlabel: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -2972,86 +2698,47 @@ pub struct IMSMQMessage4_Vtbl { pub SetHashAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lhashalg: i32) -> ::windows_core::HRESULT, pub EncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plencryptalg: *mut i32) -> ::windows_core::HRESULT, pub SetEncryptAlgorithm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lencryptalg: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SentTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ArrivedTime: usize, + pub SentTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenttime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ArrivedTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plarrivedtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub DestinationQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfodest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] DestinationQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderCertificate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SenderId: usize, + pub SenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsendercert: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSenderCertificate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsendercert: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsenderid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderidtype: *mut i32) -> ::windows_core::HRESULT, pub SetSenderIdType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsenderidtype: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Send: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, destinationqueue: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Send: usize, pub AttachCurrentSecurityContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SenderVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsenderversion: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Extension: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetExtension: usize, + pub Extension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarextension: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetExtension: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varextension: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrguidconnectortype: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetConnectorTypeGuid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrguidconnectortype: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub TransactionStatusQueueInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqinfoxactstatus: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] TransactionStatusQueueInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDestinationSymmetricKey: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Signature: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSignature: usize, + pub DestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardestsymmkey: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDestinationSymmetricKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vardestsymmkey: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Signature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsignature: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSignature: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsignature: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthprovtype: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticationProviderType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthprovtype: i32) -> ::windows_core::HRESULT, pub AuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrauthprovname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetAuthenticationProviderName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrauthprovname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSenderId: usize, + pub SetSenderId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsenderid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plmsgclass: *mut i32) -> ::windows_core::HRESULT, pub SetMsgClass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lmsgclass: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - TransactionId: usize, + pub TransactionId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarxactid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsFirstInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisfirstinxact: *mut i16) -> ::windows_core::HRESULT, pub IsLastInTransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pislastinxact: *mut i16) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -3099,19 +2786,13 @@ pub struct IMSMQMessage4_Vtbl { pub Destination: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppdestdestination: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Destination: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlookupid: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LookupId: usize, + pub LookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarlookupid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsAuthenticated2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisauthenticated: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsFirstInTransaction2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisfirstinxact: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsLastInTransaction2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pislastinxact: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub AttachCurrentSecurityContext2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SoapEnvelope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsoapenvelope: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CompoundMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CompoundMessage: usize, + pub CompoundMessage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcompoundmessage: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetSoapHeader: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsoapheader: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSoapBody: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrsoapbody: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -3126,10 +2807,8 @@ pub struct IMSMQMessage4_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQOutgoingQueueManagement, ::windows_core::IUnknown, super::Com::IDispatch, IMSMQManagement); #[cfg(feature = "Win32_System_Com")] impl IMSMQOutgoingQueueManagement { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Init(&self, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Init)(::windows_core::Interface::as_raw(self), machine, pathname, formatname).ok() + pub unsafe fn Init(&self, machine: *const ::windows_core::VARIANT, pathname: *const ::windows_core::VARIANT, formatname: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Init)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(machine), ::core::mem::transmute(pathname), ::core::mem::transmute(formatname)).ok() } pub unsafe fn FormatName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -3159,9 +2838,7 @@ impl IMSMQOutgoingQueueManagement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.TransactionalStatus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result { + pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.BytesInQueue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3169,9 +2846,7 @@ impl IMSMQOutgoingQueueManagement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).State)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NextHops(&self) -> ::windows_core::Result { + pub unsafe fn NextHops(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NextHops)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3197,10 +2872,7 @@ impl IMSMQOutgoingQueueManagement { pub struct IMSMQOutgoingQueueManagement_Vtbl { pub base__: IMSMQManagement_Vtbl, pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plstate: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NextHops: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvnexthops: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NextHops: usize, + pub NextHops: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvnexthops: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub EodGetSendInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3220,16 +2892,15 @@ pub struct IMSMQOutgoingQueueManagement_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQPrivateDestination, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQPrivateDestination { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Handle(&self) -> ::windows_core::Result { + pub unsafe fn Handle(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Handle)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetHandle(&self, varhandle: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetHandle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varhandle)).ok() + pub unsafe fn SetHandle(&self, varhandle: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetHandle)(::windows_core::Interface::as_raw(self), varhandle.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3237,14 +2908,8 @@ impl IMSMQPrivateDestination { #[doc(hidden)] pub struct IMSMQPrivateDestination_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Handle: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetHandle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varhandle: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetHandle: usize, + pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetHandle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varhandle: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3304,11 +2969,11 @@ pub struct IMSMQPrivateEvent_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQQuery, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQQuery { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3316,9 +2981,9 @@ impl IMSMQQuery { #[doc(hidden)] pub struct IMSMQQuery_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3332,11 +2997,11 @@ pub struct IMSMQQuery_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQQuery2, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQQuery2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3350,9 +3015,9 @@ impl IMSMQQuery2 { #[doc(hidden)] pub struct IMSMQQuery2_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3370,11 +3035,11 @@ pub struct IMSMQQuery2_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQQuery3, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQQuery3 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue_v2(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue_v2(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue_v2)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue_v2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3382,11 +3047,11 @@ impl IMSMQQuery3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT, multicastaddress: *const ::windows_core::VARIANT, relmulticastaddress: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, multicastaddress, relmulticastaddress, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), ::core::mem::transmute(multicastaddress), ::core::mem::transmute(relmulticastaddress), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3394,17 +3059,31 @@ impl IMSMQQuery3 { #[doc(hidden)] pub struct IMSMQQuery3_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue_v2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue_v2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue_v2: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue: unsafe extern "system" fn( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + multicastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmulticastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3418,11 +3097,11 @@ pub struct IMSMQQuery3_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQQuery4, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IMSMQQuery4 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue_v2(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue_v2(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue_v2)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue_v2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3430,11 +3109,11 @@ impl IMSMQQuery4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LookupQueue(&self, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn LookupQueue(&self, queueguid: *const ::windows_core::VARIANT, servicetypeguid: *const ::windows_core::VARIANT, label: *const ::windows_core::VARIANT, createtime: *const ::windows_core::VARIANT, modifytime: *const ::windows_core::VARIANT, relservicetype: *const ::windows_core::VARIANT, rellabel: *const ::windows_core::VARIANT, relcreatetime: *const ::windows_core::VARIANT, relmodifytime: *const ::windows_core::VARIANT, multicastaddress: *const ::windows_core::VARIANT, relmulticastaddress: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), queueguid, servicetypeguid, label, createtime, modifytime, relservicetype, rellabel, relcreatetime, relmodifytime, multicastaddress, relmulticastaddress, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).LookupQueue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(queueguid), ::core::mem::transmute(servicetypeguid), ::core::mem::transmute(label), ::core::mem::transmute(createtime), ::core::mem::transmute(modifytime), ::core::mem::transmute(relservicetype), ::core::mem::transmute(rellabel), ::core::mem::transmute(relcreatetime), ::core::mem::transmute(relmodifytime), ::core::mem::transmute(multicastaddress), ::core::mem::transmute(relmulticastaddress), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3442,17 +3121,31 @@ impl IMSMQQuery4 { #[doc(hidden)] pub struct IMSMQQuery4_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue_v2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue_v2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue_v2: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LookupQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, queueguid: *const super::Variant::VARIANT, servicetypeguid: *const super::Variant::VARIANT, label: *const super::Variant::VARIANT, createtime: *const super::Variant::VARIANT, modifytime: *const super::Variant::VARIANT, relservicetype: *const super::Variant::VARIANT, rellabel: *const super::Variant::VARIANT, relcreatetime: *const super::Variant::VARIANT, relmodifytime: *const super::Variant::VARIANT, multicastaddress: *const super::Variant::VARIANT, relmulticastaddress: *const super::Variant::VARIANT, ppqinfos: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub LookupQueue: unsafe extern "system" fn( + this: *mut ::core::ffi::c_void, + queueguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + servicetypeguid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + label: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + createtime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + modifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relservicetype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + rellabel: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relcreatetime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmodifytime: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + multicastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + relmulticastaddress: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, + ppqinfos: *mut *mut ::core::ffi::c_void, + ) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] LookupQueue: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3491,46 +3184,46 @@ impl IMSMQQueue { pub unsafe fn Close(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Close)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnableNotification(&self, event: P0, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn EnableNotification(&self, event: P0, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), cursor, receivetimeout).ok() + (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), ::core::mem::transmute(cursor), ::core::mem::transmute(receivetimeout)).ok() } pub unsafe fn Reset(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -3547,30 +3240,30 @@ pub struct IMSMQQueue_Vtbl { pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plhandle: *mut i32) -> ::windows_core::HRESULT, pub IsOpen: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut i16) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] EnableNotification: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3609,76 +3302,76 @@ impl IMSMQQueue2 { pub unsafe fn Close(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Close)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnableNotification(&self, event: P0, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn EnableNotification(&self, event: P0, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), cursor, receivetimeout).ok() + (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), ::core::mem::transmute(cursor), ::core::mem::transmute(receivetimeout)).ok() } pub unsafe fn Reset(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3701,50 +3394,50 @@ pub struct IMSMQQueue2_Vtbl { pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plhandle: *mut i32) -> ::windows_core::HRESULT, pub IsOpen: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut i16) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] EnableNotification: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3787,76 +3480,76 @@ impl IMSMQQueue3 { pub unsafe fn Close(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Close)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnableNotification(&self, event: P0, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn EnableNotification(&self, event: P0, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), cursor, receivetimeout).ok() + (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), ::core::mem::transmute(cursor), ::core::mem::transmute(receivetimeout)).ok() } pub unsafe fn Reset(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3864,71 +3557,87 @@ impl IMSMQQueue3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Handle2(&self) -> ::windows_core::Result { + pub unsafe fn Handle2(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Handle2)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveNextByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveNextByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveNextByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveNextByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceivePreviousByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceivePreviousByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceivePreviousByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceivePreviousByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveFirstByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveFirstByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveFirstByLookupId)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveFirstByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveLastByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveLastByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveLastByLookupId)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveLastByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNextByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNextByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNextByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNextByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekPreviousByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekPreviousByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekPreviousByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekPreviousByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekFirstByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekFirstByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekFirstByLookupId)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekFirstByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekLastByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekLastByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekLastByLookupId)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekLastByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } pub unsafe fn Purge(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Purge)(::windows_core::Interface::as_raw(self)).ok() @@ -3952,98 +3661,95 @@ pub struct IMSMQQueue3_Vtbl { pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plhandle: *mut i32) -> ::windows_core::HRESULT, pub IsOpen: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut i16) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] EnableNotification: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Handle2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Handle2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Handle2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ReceiveByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveNextByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceivePreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceivePreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceivePreviousByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveFirstByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveLastByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNextByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekPreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekPreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekPreviousByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekFirstByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekLastByLookupId: usize, pub Purge: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub IsOpen2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -4084,76 +3790,76 @@ impl IMSMQQueue4 { pub unsafe fn Close(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Close)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnableNotification(&self, event: P0, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn EnableNotification(&self, event: P0, cursor: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), cursor, receivetimeout).ok() + (::windows_core::Interface::vtable(self).EnableNotification)(::windows_core::Interface::as_raw(self), event.into_param().abi(), ::core::mem::transmute(cursor), ::core::mem::transmute(receivetimeout)).ok() } pub unsafe fn Reset(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Reset)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent_v1(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent_v1(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent_v1)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Receive(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Receive(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Receive)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Peek(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Peek(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Peek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveCurrent(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveCurrent(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNext(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNext(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNext)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekCurrent(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, receivetimeout: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, receivetimeout, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekCurrent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(receivetimeout), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4161,71 +3867,87 @@ impl IMSMQQueue4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Handle2(&self) -> ::windows_core::Result { + pub unsafe fn Handle2(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Handle2)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveNextByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveNextByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveNextByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveNextByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceivePreviousByLookupId(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceivePreviousByLookupId(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceivePreviousByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceivePreviousByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveFirstByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveFirstByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveFirstByLookupId)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveFirstByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveLastByLookupId(&self, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveLastByLookupId(&self, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveLastByLookupId)(::windows_core::Interface::as_raw(self), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveLastByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekNextByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekNextByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekNextByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekNextByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekPreviousByLookupId(&self, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekPreviousByLookupId(&self, lookupid: P0, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekPreviousByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekPreviousByLookupId)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekFirstByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekFirstByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekFirstByLookupId)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekFirstByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PeekLastByLookupId(&self, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PeekLastByLookupId(&self, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PeekLastByLookupId)(::windows_core::Interface::as_raw(self), wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PeekLastByLookupId)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } pub unsafe fn Purge(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Purge)(::windows_core::Interface::as_raw(self)).ok() @@ -4234,11 +3956,14 @@ impl IMSMQQueue4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsOpen2)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReceiveByLookupIdAllowPeek(&self, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ReceiveByLookupIdAllowPeek(&self, lookupid: P0, transaction: *const ::windows_core::VARIANT, wantdestinationqueue: *const ::windows_core::VARIANT, wantbody: *const ::windows_core::VARIANT, wantconnectortype: *const ::windows_core::VARIANT) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ReceiveByLookupIdAllowPeek)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(lookupid), transaction, wantdestinationqueue, wantbody, wantconnectortype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ReceiveByLookupIdAllowPeek)(::windows_core::Interface::as_raw(self), lookupid.into_param().abi(), ::core::mem::transmute(transaction), ::core::mem::transmute(wantdestinationqueue), ::core::mem::transmute(wantbody), ::core::mem::transmute(wantconnectortype), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -4255,104 +3980,101 @@ pub struct IMSMQQueue4_Vtbl { pub Handle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plhandle: *mut i32) -> ::windows_core::HRESULT, pub IsOpen: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut i16) -> ::windows_core::HRESULT, pub Close: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub EnableNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, event: *mut ::core::ffi::c_void, cursor: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] EnableNotification: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent_v1: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent_v1: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Receive: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Receive: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Peek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Peek: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveCurrent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNext: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, receivetimeout: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekCurrent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, receivetimeout: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekCurrent: usize, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Handle2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Handle2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Handle2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarhandle: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub ReceiveByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveNextByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceivePreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceivePreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceivePreviousByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveFirstByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveLastByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekNextByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekNextByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekPreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekPreviousByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekPreviousByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekFirstByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekFirstByLookupId: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PeekLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub PeekLastByLookupId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PeekLastByLookupId: usize, pub Purge: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub IsOpen2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisopen: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReceiveByLookupIdAllowPeek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: super::Variant::VARIANT, transaction: *const super::Variant::VARIANT, wantdestinationqueue: *const super::Variant::VARIANT, wantbody: *const super::Variant::VARIANT, wantconnectortype: *const super::Variant::VARIANT, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ReceiveByLookupIdAllowPeek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lookupid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, transaction: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantdestinationqueue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantbody: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, wantconnectortype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppmsg: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ReceiveByLookupIdAllowPeek: usize, } #[cfg(feature = "Win32_System_Com")] @@ -4442,15 +4164,11 @@ impl IMSMQQueueInfo { pub unsafe fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetBasePriority)(::windows_core::Interface::as_raw(self), lbasepriority).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTime(&self) -> ::windows_core::Result { + pub unsafe fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ModifyTime(&self) -> ::windows_core::Result { + pub unsafe fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ModifyTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4472,10 +4190,8 @@ impl IMSMQQueueInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsWorldReadable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), istransactional, isworldreadable).ok() + pub unsafe fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(istransactional), ::core::mem::transmute(isworldreadable)).ok() } pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -4516,23 +4232,14 @@ pub struct IMSMQQueueInfo_Vtbl { pub SetQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lquota: i32) -> ::windows_core::HRESULT, pub BasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plbasepriority: *mut i32) -> ::windows_core::HRESULT, pub SetBasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lbasepriority: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ModifyTime: usize, + pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Authenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthenticate: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthenticate: i32) -> ::windows_core::HRESULT, pub JournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pljournalquota: *mut i32) -> ::windows_core::HRESULT, pub SetJournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ljournalquota: i32) -> ::windows_core::HRESULT, pub IsWorldReadable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut i16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Create: usize, + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, access: i32, sharemode: i32, ppq: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4628,15 +4335,11 @@ impl IMSMQQueueInfo2 { pub unsafe fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetBasePriority)(::windows_core::Interface::as_raw(self), lbasepriority).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTime(&self) -> ::windows_core::Result { + pub unsafe fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ModifyTime(&self) -> ::windows_core::Result { + pub unsafe fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ModifyTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4658,10 +4361,8 @@ impl IMSMQQueueInfo2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsWorldReadable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), istransactional, isworldreadable).ok() + pub unsafe fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(istransactional), ::core::mem::transmute(isworldreadable)).ok() } pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -4688,16 +4389,15 @@ impl IMSMQQueueInfo2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Security(&self) -> ::windows_core::Result { + pub unsafe fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Security)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSecurity(&self, varsecurity: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsecurity)).ok() + pub unsafe fn SetSecurity(&self, varsecurity: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), varsecurity.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4723,23 +4423,14 @@ pub struct IMSMQQueueInfo2_Vtbl { pub SetQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lquota: i32) -> ::windows_core::HRESULT, pub BasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plbasepriority: *mut i32) -> ::windows_core::HRESULT, pub SetBasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lbasepriority: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ModifyTime: usize, + pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Authenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthenticate: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthenticate: i32) -> ::windows_core::HRESULT, pub JournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pljournalquota: *mut i32) -> ::windows_core::HRESULT, pub SetJournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ljournalquota: i32) -> ::windows_core::HRESULT, pub IsWorldReadable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut i16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Create: usize, + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, access: i32, sharemode: i32, ppq: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4752,14 +4443,8 @@ pub struct IMSMQQueueInfo2_Vtbl { pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Security: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSecurity: usize, + pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4848,15 +4533,11 @@ impl IMSMQQueueInfo3 { pub unsafe fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetBasePriority)(::windows_core::Interface::as_raw(self), lbasepriority).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTime(&self) -> ::windows_core::Result { + pub unsafe fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ModifyTime(&self) -> ::windows_core::Result { + pub unsafe fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ModifyTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4878,10 +4559,8 @@ impl IMSMQQueueInfo3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsWorldReadable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), istransactional, isworldreadable).ok() + pub unsafe fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(istransactional), ::core::mem::transmute(isworldreadable)).ok() } pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -4908,16 +4587,15 @@ impl IMSMQQueueInfo3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Security(&self) -> ::windows_core::Result { + pub unsafe fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Security)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSecurity(&self, varsecurity: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsecurity)).ok() + pub unsafe fn SetSecurity(&self, varsecurity: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), varsecurity.into_param().abi()).ok() } pub unsafe fn IsTransactional2(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4965,23 +4643,14 @@ pub struct IMSMQQueueInfo3_Vtbl { pub SetQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lquota: i32) -> ::windows_core::HRESULT, pub BasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plbasepriority: *mut i32) -> ::windows_core::HRESULT, pub SetBasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lbasepriority: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ModifyTime: usize, + pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Authenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthenticate: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthenticate: i32) -> ::windows_core::HRESULT, pub JournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pljournalquota: *mut i32) -> ::windows_core::HRESULT, pub SetJournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ljournalquota: i32) -> ::windows_core::HRESULT, pub IsWorldReadable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut i16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Create: usize, + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, access: i32, sharemode: i32, ppq: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4994,14 +4663,8 @@ pub struct IMSMQQueueInfo3_Vtbl { pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Security: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSecurity: usize, + pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsTransactional2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pistransactional: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsWorldReadable2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub MulticastAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrmulticastaddress: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -5095,15 +4758,11 @@ impl IMSMQQueueInfo4 { pub unsafe fn SetBasePriority(&self, lbasepriority: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetBasePriority)(::windows_core::Interface::as_raw(self), lbasepriority).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateTime(&self) -> ::windows_core::Result { + pub unsafe fn CreateTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ModifyTime(&self) -> ::windows_core::Result { + pub unsafe fn ModifyTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ModifyTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5125,10 +4784,8 @@ impl IMSMQQueueInfo4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsWorldReadable)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Create(&self, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), istransactional, isworldreadable).ok() + pub unsafe fn Create(&self, istransactional: *const ::windows_core::VARIANT, isworldreadable: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(istransactional), ::core::mem::transmute(isworldreadable)).ok() } pub unsafe fn Delete(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self)).ok() @@ -5155,16 +4812,15 @@ impl IMSMQQueueInfo4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Security(&self) -> ::windows_core::Result { + pub unsafe fn Security(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Security)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSecurity(&self, varsecurity: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varsecurity)).ok() + pub unsafe fn SetSecurity(&self, varsecurity: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSecurity)(::windows_core::Interface::as_raw(self), varsecurity.into_param().abi()).ok() } pub unsafe fn IsTransactional2(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5212,23 +4868,14 @@ pub struct IMSMQQueueInfo4_Vtbl { pub SetQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lquota: i32) -> ::windows_core::HRESULT, pub BasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plbasepriority: *mut i32) -> ::windows_core::HRESULT, pub SetBasePriority: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lbasepriority: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ModifyTime: usize, + pub CreateTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcreatetime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ModifyTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarmodifytime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Authenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plauthenticate: *mut i32) -> ::windows_core::HRESULT, pub SetAuthenticate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lauthenticate: i32) -> ::windows_core::HRESULT, pub JournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pljournalquota: *mut i32) -> ::windows_core::HRESULT, pub SetJournalQuota: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ljournalquota: i32) -> ::windows_core::HRESULT, pub IsWorldReadable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut i16) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const super::Variant::VARIANT, isworldreadable: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Create: usize, + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, istransactional: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, isworldreadable: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, access: i32, sharemode: i32, ppq: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5241,14 +4888,8 @@ pub struct IMSMQQueueInfo4_Vtbl { pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Properties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Security: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSecurity: usize, + pub Security: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsecurity: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varsecurity: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsTransactional2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pistransactional: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsWorldReadable2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pisworldreadable: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub MulticastAddress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrmulticastaddress: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -5424,10 +5065,8 @@ pub struct IMSMQQueueInfos4_Vtbl { ::windows_core::imp::interface_hierarchy!(IMSMQQueueManagement, ::windows_core::IUnknown, super::Com::IDispatch, IMSMQManagement); #[cfg(feature = "Win32_System_Com")] impl IMSMQQueueManagement { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Init(&self, machine: *const super::Variant::VARIANT, pathname: *const super::Variant::VARIANT, formatname: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Init)(::windows_core::Interface::as_raw(self), machine, pathname, formatname).ok() + pub unsafe fn Init(&self, machine: *const ::windows_core::VARIANT, pathname: *const ::windows_core::VARIANT, formatname: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Init)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(machine), ::core::mem::transmute(pathname), ::core::mem::transmute(formatname)).ok() } pub unsafe fn FormatName(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -5457,9 +5096,7 @@ impl IMSMQQueueManagement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.TransactionalStatus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result { + pub unsafe fn BytesInQueue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.BytesInQueue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5467,15 +5104,11 @@ impl IMSMQQueueManagement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).JournalMessageCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BytesInJournal(&self) -> ::windows_core::Result { + pub unsafe fn BytesInJournal(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BytesInJournal)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EodGetReceiveInfo(&self) -> ::windows_core::Result { + pub unsafe fn EodGetReceiveInfo(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EodGetReceiveInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5486,14 +5119,8 @@ impl IMSMQQueueManagement { pub struct IMSMQQueueManagement_Vtbl { pub base__: IMSMQManagement_Vtbl, pub JournalMessageCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pljournalmessagecount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BytesInJournal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinjournal: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BytesInJournal: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EodGetReceiveInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvcollection: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EodGetReceiveInfo: usize, + pub BytesInJournal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvbytesinjournal: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub EodGetReceiveInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvcollection: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5510,15 +5137,11 @@ impl IMSMQTransaction { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Transaction)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Commit(&self, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Commit)(::windows_core::Interface::as_raw(self), fretaining, grftc, grfrm).ok() + pub unsafe fn Commit(&self, fretaining: *const ::windows_core::VARIANT, grftc: *const ::windows_core::VARIANT, grfrm: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Commit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(grftc), ::core::mem::transmute(grfrm)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Abort(&self, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Abort)(::windows_core::Interface::as_raw(self), fretaining, fasync).ok() + pub unsafe fn Abort(&self, fretaining: *const ::windows_core::VARIANT, fasync: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Abort)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(fasync)).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -5527,14 +5150,8 @@ impl IMSMQTransaction { pub struct IMSMQTransaction_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Transaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pltransaction: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Commit: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Abort: usize, + pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fretaining: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, grftc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, grfrm: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Abort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fretaining: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, fasync: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -5551,20 +5168,17 @@ impl IMSMQTransaction2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Transaction)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Commit(&self, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Commit)(::windows_core::Interface::as_raw(self), fretaining, grftc, grfrm).ok() + pub unsafe fn Commit(&self, fretaining: *const ::windows_core::VARIANT, grftc: *const ::windows_core::VARIANT, grfrm: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Commit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(grftc), ::core::mem::transmute(grfrm)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Abort(&self, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Abort)(::windows_core::Interface::as_raw(self), fretaining, fasync).ok() + pub unsafe fn Abort(&self, fretaining: *const ::windows_core::VARIANT, fasync: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Abort)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(fasync)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitNew(&self, vartransaction: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InitNew)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartransaction)).ok() + pub unsafe fn InitNew(&self, vartransaction: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).InitNew)(::windows_core::Interface::as_raw(self), vartransaction.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5578,10 +5192,7 @@ impl IMSMQTransaction2 { #[doc(hidden)] pub struct IMSMQTransaction2_Vtbl { pub base__: IMSMQTransaction_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InitNew: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartransaction: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InitNew: usize, + pub InitNew: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vartransaction: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Properties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcolproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -5602,20 +5213,17 @@ impl IMSMQTransaction3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Transaction)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Commit(&self, fretaining: *const super::Variant::VARIANT, grftc: *const super::Variant::VARIANT, grfrm: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Commit)(::windows_core::Interface::as_raw(self), fretaining, grftc, grfrm).ok() + pub unsafe fn Commit(&self, fretaining: *const ::windows_core::VARIANT, grftc: *const ::windows_core::VARIANT, grfrm: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.Commit)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(grftc), ::core::mem::transmute(grfrm)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Abort(&self, fretaining: *const super::Variant::VARIANT, fasync: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Abort)(::windows_core::Interface::as_raw(self), fretaining, fasync).ok() + pub unsafe fn Abort(&self, fretaining: *const ::windows_core::VARIANT, fasync: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.Abort)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(fretaining), ::core::mem::transmute(fasync)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InitNew(&self, vartransaction: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.InitNew)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vartransaction)).ok() + pub unsafe fn InitNew(&self, vartransaction: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.InitNew)(::windows_core::Interface::as_raw(self), vartransaction.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5623,9 +5231,7 @@ impl IMSMQTransaction3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Properties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ITransaction(&self) -> ::windows_core::Result { + pub unsafe fn ITransaction(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ITransaction)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5635,10 +5241,7 @@ impl IMSMQTransaction3 { #[doc(hidden)] pub struct IMSMQTransaction3_Vtbl { pub base__: IMSMQTransaction2_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ITransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaritransaction: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ITransaction: usize, + pub ITransaction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaritransaction: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6732,268 +6335,220 @@ impl ::core::default::Default for MQCOLUMNSET { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQMGMTPROPS { pub cProp: u32, pub aPropID: *mut u32, - pub aPropVar: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aPropVar: *mut ::windows_core::PROPVARIANT, pub aStatus: *mut ::windows_core::HRESULT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQMGMTPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQMGMTPROPS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQMGMTPROPS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQMGMTPROPS").field("cProp", &self.cProp).field("aPropID", &self.aPropID).field("aPropVar", &self.aPropVar).field("aStatus", &self.aStatus).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQMGMTPROPS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQMGMTPROPS { fn eq(&self, other: &Self) -> bool { self.cProp == other.cProp && self.aPropID == other.aPropID && self.aPropVar == other.aPropVar && self.aStatus == other.aStatus } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQMGMTPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQMGMTPROPS { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQMSGPROPS { pub cProp: u32, pub aPropID: *mut u32, - pub aPropVar: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aPropVar: *mut ::windows_core::PROPVARIANT, pub aStatus: *mut ::windows_core::HRESULT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQMSGPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQMSGPROPS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQMSGPROPS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQMSGPROPS").field("cProp", &self.cProp).field("aPropID", &self.aPropID).field("aPropVar", &self.aPropVar).field("aStatus", &self.aStatus).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQMSGPROPS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQMSGPROPS { fn eq(&self, other: &Self) -> bool { self.cProp == other.cProp && self.aPropID == other.aPropID && self.aPropVar == other.aPropVar && self.aStatus == other.aStatus } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQMSGPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQMSGPROPS { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQPRIVATEPROPS { pub cProp: u32, pub aPropID: *mut u32, - pub aPropVar: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aPropVar: *mut ::windows_core::PROPVARIANT, pub aStatus: *mut ::windows_core::HRESULT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQPRIVATEPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQPRIVATEPROPS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQPRIVATEPROPS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQPRIVATEPROPS").field("cProp", &self.cProp).field("aPropID", &self.aPropID).field("aPropVar", &self.aPropVar).field("aStatus", &self.aStatus).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQPRIVATEPROPS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQPRIVATEPROPS { fn eq(&self, other: &Self) -> bool { self.cProp == other.cProp && self.aPropID == other.aPropID && self.aPropVar == other.aPropVar && self.aStatus == other.aStatus } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQPRIVATEPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQPRIVATEPROPS { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQPROPERTYRESTRICTION { pub rel: u32, pub prop: u32, - pub prval: super::Com::StructuredStorage::PROPVARIANT, + pub prval: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQPROPERTYRESTRICTION { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for MQPROPERTYRESTRICTION { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("MQPROPERTYRESTRICTION").field("rel", &self.rel).field("prop", &self.prop).field("prval", &self.prval).finish() + } +} impl ::windows_core::TypeKind for MQPROPERTYRESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for MQPROPERTYRESTRICTION { + fn eq(&self, other: &Self) -> bool { + self.rel == other.rel && self.prop == other.prop && self.prval == other.prval + } +} +impl ::core::cmp::Eq for MQPROPERTYRESTRICTION {} impl ::core::default::Default for MQPROPERTYRESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQQMPROPS { pub cProp: u32, pub aPropID: *mut u32, - pub aPropVar: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aPropVar: *mut ::windows_core::PROPVARIANT, pub aStatus: *mut ::windows_core::HRESULT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQQMPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQQMPROPS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQQMPROPS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQQMPROPS").field("cProp", &self.cProp).field("aPropID", &self.aPropID).field("aPropVar", &self.aPropVar).field("aStatus", &self.aStatus).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQQMPROPS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQQMPROPS { fn eq(&self, other: &Self) -> bool { self.cProp == other.cProp && self.aPropID == other.aPropID && self.aPropVar == other.aPropVar && self.aStatus == other.aStatus } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQQMPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQQMPROPS { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQQUEUEPROPS { pub cProp: u32, pub aPropID: *mut u32, - pub aPropVar: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aPropVar: *mut ::windows_core::PROPVARIANT, pub aStatus: *mut ::windows_core::HRESULT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQQUEUEPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQQUEUEPROPS { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQQUEUEPROPS { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQQUEUEPROPS").field("cProp", &self.cProp).field("aPropID", &self.aPropID).field("aPropVar", &self.aPropVar).field("aStatus", &self.aStatus).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQQUEUEPROPS { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQQUEUEPROPS { fn eq(&self, other: &Self) -> bool { self.cProp == other.cProp && self.aPropID == other.aPropID && self.aPropVar == other.aPropVar && self.aStatus == other.aStatus } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQQUEUEPROPS {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQQUEUEPROPS { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct MQRESTRICTION { pub cRes: u32, pub paPropRes: *mut MQPROPERTYRESTRICTION, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for MQRESTRICTION {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MQRESTRICTION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for MQRESTRICTION { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("MQRESTRICTION").field("cRes", &self.cRes).field("paPropRes", &self.paPropRes).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for MQRESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for MQRESTRICTION { fn eq(&self, other: &Self) -> bool { self.cRes == other.cRes && self.paPropRes == other.paPropRes } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for MQRESTRICTION {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for MQRESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -7090,8 +6645,8 @@ impl ::core::default::Default for SEQUENCE_INFO { unsafe { ::core::mem::zeroed() } } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_IO\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_IO", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_IO\"`"] +#[cfg(feature = "Win32_System_IO")] pub type PMQRECEIVECALLBACK = ::core::option::Option; #[cfg(feature = "implement")] ::core::include!("impl.rs"); diff --git a/crates/libs/windows/src/Windows/Win32/System/Mmc/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Mmc/impl.rs index adfc632e01..ff78840784 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Mmc/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Mmc/impl.rs @@ -1,9 +1,9 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait AppEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for AppEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl AppEvents_Vtbl { pub const fn new, Impl: AppEvents_Impl, const OFFSET: isize>() -> AppEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -12,8 +12,8 @@ impl AppEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Column_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Width(&self) -> ::windows_core::Result; @@ -25,9 +25,9 @@ pub trait Column_Impl: Sized + super::Com::IDispatch_Impl { fn SetAsSortColumn(&self, sortorder: _ColumnSortOrder) -> ::windows_core::Result<()>; fn IsSortColumn(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Column {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Column_Vtbl { pub const fn new, Impl: Column_Impl, const OFFSET: isize>() -> Column_Vtbl { unsafe extern "system" fn Name, Impl: Column_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -122,16 +122,16 @@ impl Column_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Columns_Impl: Sized + super::Com::IDispatch_Impl { fn Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Columns {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Columns_Vtbl { pub const fn new, Impl: Columns_Impl, const OFFSET: isize>() -> Columns_Vtbl { unsafe extern "system" fn Item, Impl: Columns_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, column: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -178,16 +178,16 @@ impl Columns_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ContextMenu_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, indexorpath: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, indexorpath: &::windows_core::VARIANT) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ContextMenu {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ContextMenu_Vtbl { pub const fn new, Impl: ContextMenu_Impl, const OFFSET: isize>() -> ContextMenu_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ContextMenu_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -201,7 +201,7 @@ impl ContextMenu_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ContextMenu_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexorpath: super::Variant::VARIANT, menuitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ContextMenu_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexorpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, menuitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&indexorpath)) { @@ -234,8 +234,8 @@ impl ContextMenu_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Document_Impl: Sized + super::Com::IDispatch_Impl { fn Save(&self) -> ::windows_core::Result<()>; fn SaveAs(&self, filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -254,9 +254,9 @@ pub trait Document_Impl: Sized + super::Com::IDispatch_Impl { fn CreateProperties(&self) -> ::windows_core::Result; fn Application(&self) -> ::windows_core::Result<_Application>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Document {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Document_Vtbl { pub const fn new, Impl: Document_Impl, const OFFSET: isize>() -> Document_Vtbl { unsafe extern "system" fn Save, Impl: Document_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -429,8 +429,8 @@ impl Document_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Extension_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Vendor(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -440,9 +440,9 @@ pub trait Extension_Impl: Sized + super::Com::IDispatch_Impl { fn EnableAllExtensions(&self, enable: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn Enable(&self, enable: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Extension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Extension_Vtbl { pub const fn new, Impl: Extension_Impl, const OFFSET: isize>() -> Extension_Vtbl { unsafe extern "system" fn Name, Impl: Extension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -525,16 +525,16 @@ impl Extension_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Extensions_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Extensions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Extensions_Vtbl { pub const fn new, Impl: Extensions_Impl, const OFFSET: isize>() -> Extensions_Vtbl { unsafe extern "system" fn _NewEnum, Impl: Extensions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -581,8 +581,8 @@ impl Extensions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Frame_Impl: Sized + super::Com::IDispatch_Impl { fn Maximize(&self) -> ::windows_core::Result<()>; fn Minimize(&self) -> ::windows_core::Result<()>; @@ -596,9 +596,9 @@ pub trait Frame_Impl: Sized + super::Com::IDispatch_Impl { fn Right(&self) -> ::windows_core::Result; fn SetRight(&self, right: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Frame {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Frame_Vtbl { pub const fn new, Impl: Frame_Impl, const OFFSET: isize>() -> Frame_Vtbl { unsafe extern "system" fn Maximize, Impl: Frame_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1653,22 +1653,22 @@ impl IExtendPropertySheet2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IExtendTaskPad_Impl: Sized { - fn TaskNotify(&self, pdo: ::core::option::Option<&super::Com::IDataObject>, arg: *const super::Variant::VARIANT, param2: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn TaskNotify(&self, pdo: ::core::option::Option<&super::Com::IDataObject>, arg: *const ::windows_core::VARIANT, param2: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EnumTasks(&self, pdo: ::core::option::Option<&super::Com::IDataObject>, sztaskgroup: &::windows_core::PCWSTR) -> ::windows_core::Result; fn GetTitle(&self, pszgroup: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetDescriptiveText(&self, pszgroup: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetBackground(&self, pszgroup: &::windows_core::PCWSTR) -> ::windows_core::Result; fn GetListPadInfo(&self, pszgroup: &::windows_core::PCWSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IExtendTaskPad {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IExtendTaskPad_Vtbl { pub const fn new, Impl: IExtendTaskPad_Impl, const OFFSET: isize>() -> IExtendTaskPad_Vtbl { - unsafe extern "system" fn TaskNotify, Impl: IExtendTaskPad_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdo: *mut ::core::ffi::c_void, arg: *const super::Variant::VARIANT, param2: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn TaskNotify, Impl: IExtendTaskPad_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdo: *mut ::core::ffi::c_void, arg: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, param2: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.TaskNotify(::windows_core::from_raw_borrowed(&pdo), ::core::mem::transmute_copy(&arg), ::core::mem::transmute_copy(¶m2)).into() @@ -2488,16 +2488,16 @@ impl ISnapinHelp2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISnapinProperties_Impl: Sized { fn Initialize(&self, pproperties: ::core::option::Option<&Properties>) -> ::windows_core::Result<()>; fn QueryPropertyNames(&self, pcallback: ::core::option::Option<&ISnapinPropertiesCallback>) -> ::windows_core::Result<()>; fn PropertiesChanged(&self, cproperties: i32, pproperties: *const MMC_SNAPIN_PROPERTY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISnapinProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISnapinProperties_Vtbl { pub const fn new, Impl: ISnapinProperties_Impl, const OFFSET: isize>() -> ISnapinProperties_Vtbl { unsafe extern "system" fn Initialize, Impl: ISnapinProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pproperties: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2715,8 +2715,8 @@ impl IViewExtensionCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait MenuItem_Impl: Sized + super::Com::IDispatch_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LanguageIndependentName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2725,9 +2725,9 @@ pub trait MenuItem_Impl: Sized + super::Com::IDispatch_Impl { fn Execute(&self) -> ::windows_core::Result<()>; fn Enabled(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for MenuItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl MenuItem_Vtbl { pub const fn new, Impl: MenuItem_Impl, const OFFSET: isize>() -> MenuItem_Vtbl { unsafe extern "system" fn DisplayName, Impl: MenuItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, displayname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2804,8 +2804,8 @@ impl MenuItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Node_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn get_Property(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2813,9 +2813,9 @@ pub trait Node_Impl: Sized + super::Com::IDispatch_Impl { fn IsScopeNode(&self) -> ::windows_core::Result; fn Nodetype(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Node {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Node_Vtbl { pub const fn new, Impl: Node_Impl, const OFFSET: isize>() -> Node_Vtbl { unsafe extern "system" fn Name, Impl: Node_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2886,16 +2886,16 @@ impl Node_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Nodes_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Nodes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Nodes_Vtbl { pub const fn new, Impl: Nodes_Impl, const OFFSET: isize>() -> Nodes_Vtbl { unsafe extern "system" fn _NewEnum, Impl: Nodes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2942,17 +2942,17 @@ impl Nodes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Properties_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn Remove(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Properties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Properties_Vtbl { pub const fn new, Impl: Properties_Impl, const OFFSET: isize>() -> Properties_Vtbl { unsafe extern "system" fn _NewEnum, Impl: Properties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3005,19 +3005,19 @@ impl Properties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Property_Impl: Sized + super::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Property {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Property_Vtbl { pub const fn new, Impl: Property_Impl, const OFFSET: isize>() -> Property_Vtbl { - unsafe extern "system" fn Value, Impl: Property_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: Property_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -3028,7 +3028,7 @@ impl Property_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: Property_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: Property_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&value)).into() @@ -3055,8 +3055,8 @@ impl Property_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ScopeNamespace_Impl: Sized + super::Com::IDispatch_Impl { fn GetParent(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result; fn GetChild(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result; @@ -3064,9 +3064,9 @@ pub trait ScopeNamespace_Impl: Sized + super::Com::IDispatch_Impl { fn GetRoot(&self) -> ::windows_core::Result; fn Expand(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ScopeNamespace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ScopeNamespace_Vtbl { pub const fn new, Impl: ScopeNamespace_Impl, const OFFSET: isize>() -> ScopeNamespace_Vtbl { unsafe extern "system" fn GetParent, Impl: ScopeNamespace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, node: *mut ::core::ffi::c_void, parent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3131,8 +3131,8 @@ impl ScopeNamespace_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait SnapIn_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Vendor(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -3142,9 +3142,9 @@ pub trait SnapIn_Impl: Sized + super::Com::IDispatch_Impl { fn Properties(&self) -> ::windows_core::Result; fn EnableAllExtensions(&self, enable: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for SnapIn {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl SnapIn_Vtbl { pub const fn new, Impl: SnapIn_Impl, const OFFSET: isize>() -> SnapIn_Vtbl { unsafe extern "system" fn Name, Impl: SnapIn_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3233,18 +3233,18 @@ impl SnapIn_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait SnapIns_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; - fn Add(&self, snapinnameorclsid: &::windows_core::BSTR, parentsnapin: &super::Variant::VARIANT, properties: &super::Variant::VARIANT) -> ::windows_core::Result; + fn Add(&self, snapinnameorclsid: &::windows_core::BSTR, parentsnapin: &::windows_core::VARIANT, properties: &::windows_core::VARIANT) -> ::windows_core::Result; fn Remove(&self, snapin: ::core::option::Option<&SnapIn>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for SnapIns {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl SnapIns_Vtbl { pub const fn new, Impl: SnapIns_Impl, const OFFSET: isize>() -> SnapIns_Vtbl { unsafe extern "system" fn _NewEnum, Impl: SnapIns_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3280,7 +3280,7 @@ impl SnapIns_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: SnapIns_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapinnameorclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, parentsnapin: super::Variant::VARIANT, properties: super::Variant::VARIANT, snapin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: SnapIns_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, snapinnameorclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, parentsnapin: ::std::mem::MaybeUninit<::windows_core::VARIANT>, properties: ::std::mem::MaybeUninit<::windows_core::VARIANT>, snapin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::core::mem::transmute(&snapinnameorclsid), ::core::mem::transmute(&parentsnapin), ::core::mem::transmute(&properties)) { @@ -3309,14 +3309,14 @@ impl SnapIns_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait View_Impl: Sized + super::Com::IDispatch_Impl { fn ActiveScopeNode(&self) -> ::windows_core::Result; fn SetActiveScopeNode(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result<()>; fn Selection(&self) -> ::windows_core::Result; fn ListItems(&self) -> ::windows_core::Result; - fn SnapinScopeObject(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result; + fn SnapinScopeObject(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result; fn SnapinSelectionObject(&self) -> ::windows_core::Result; fn Is(&self, view: ::core::option::Option<&View>) -> ::windows_core::Result; fn Document(&self) -> ::windows_core::Result; @@ -3324,20 +3324,20 @@ pub trait View_Impl: Sized + super::Com::IDispatch_Impl { fn Select(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result<()>; fn Deselect(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result<()>; fn IsSelected(&self, node: ::core::option::Option<&Node>) -> ::windows_core::Result; - fn DisplayScopeNodePropertySheet(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DisplayScopeNodePropertySheet(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DisplaySelectionPropertySheet(&self) -> ::windows_core::Result<()>; - fn CopyScopeNode(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CopyScopeNode(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn CopySelection(&self) -> ::windows_core::Result<()>; - fn DeleteScopeNode(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DeleteScopeNode(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DeleteSelection(&self) -> ::windows_core::Result<()>; - fn RenameScopeNode(&self, newname: &::windows_core::BSTR, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RenameScopeNode(&self, newname: &::windows_core::BSTR, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RenameSelectedItem(&self, newname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn get_ScopeNodeContextMenu(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_ScopeNodeContextMenu(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result; fn SelectionContextMenu(&self) -> ::windows_core::Result; - fn RefreshScopeNode(&self, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn RefreshScopeNode(&self, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn RefreshSelection(&self) -> ::windows_core::Result<()>; fn ExecuteSelectionMenuItem(&self, menuitempath: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn ExecuteScopeNodeMenuItem(&self, menuitempath: &::windows_core::BSTR, scopenode: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ExecuteScopeNodeMenuItem(&self, menuitempath: &::windows_core::BSTR, scopenode: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ExecuteShellCommand(&self, command: &::windows_core::BSTR, directory: &::windows_core::BSTR, parameters: &::windows_core::BSTR, windowstate: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Frame(&self) -> ::windows_core::Result; fn Close(&self) -> ::windows_core::Result<()>; @@ -3355,9 +3355,9 @@ pub trait View_Impl: Sized + super::Com::IDispatch_Impl { fn SetListViewMode(&self, mode: _ListViewMode) -> ::windows_core::Result<()>; fn ControlObject(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for View {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl View_Vtbl { pub const fn new, Impl: View_Impl, const OFFSET: isize>() -> View_Vtbl { unsafe extern "system" fn ActiveScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, node: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3398,7 +3398,7 @@ impl View_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SnapinScopeObject, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT, scopenodeobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn SnapinScopeObject, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, scopenodeobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SnapinScopeObject(::core::mem::transmute(&scopenode)) { @@ -3468,7 +3468,7 @@ impl View_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn DisplayScopeNodePropertySheet, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DisplayScopeNodePropertySheet, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DisplayScopeNodePropertySheet(::core::mem::transmute(&scopenode)).into() @@ -3478,7 +3478,7 @@ impl View_Vtbl { let this = (*this).get_impl(); this.DisplaySelectionPropertySheet().into() } - unsafe extern "system" fn CopyScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CopyScopeNode(::core::mem::transmute(&scopenode)).into() @@ -3488,7 +3488,7 @@ impl View_Vtbl { let this = (*this).get_impl(); this.CopySelection().into() } - unsafe extern "system" fn DeleteScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DeleteScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DeleteScopeNode(::core::mem::transmute(&scopenode)).into() @@ -3498,7 +3498,7 @@ impl View_Vtbl { let this = (*this).get_impl(); this.DeleteSelection().into() } - unsafe extern "system" fn RenameScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newname: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RenameScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newname: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RenameScopeNode(::core::mem::transmute(&newname), ::core::mem::transmute(&scopenode)).into() @@ -3508,7 +3508,7 @@ impl View_Vtbl { let this = (*this).get_impl(); this.RenameSelectedItem(::core::mem::transmute(&newname)).into() } - unsafe extern "system" fn get_ScopeNodeContextMenu, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT, contextmenu: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_ScopeNodeContextMenu, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, contextmenu: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_ScopeNodeContextMenu(::core::mem::transmute(&scopenode)) { @@ -3530,7 +3530,7 @@ impl View_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RefreshScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RefreshScopeNode, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.RefreshScopeNode(::core::mem::transmute(&scopenode)).into() @@ -3545,7 +3545,7 @@ impl View_Vtbl { let this = (*this).get_impl(); this.ExecuteSelectionMenuItem(::core::mem::transmute(&menuitempath)).into() } - unsafe extern "system" fn ExecuteScopeNodeMenuItem, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, menuitempath: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExecuteScopeNodeMenuItem, Impl: View_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, menuitempath: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ExecuteScopeNodeMenuItem(::core::mem::transmute(&menuitempath), ::core::mem::transmute(&scopenode)).into() @@ -3722,17 +3722,17 @@ impl View_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Views_Impl: Sized + super::Com::IDispatch_Impl { fn Item(&self, index: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; fn Add(&self, node: ::core::option::Option<&Node>, viewoptions: _ViewOptions) -> ::windows_core::Result<()>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Views {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Views_Vtbl { pub const fn new, Impl: Views_Impl, const OFFSET: isize>() -> Views_Vtbl { unsafe extern "system" fn Item, Impl: Views_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, view: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3785,8 +3785,8 @@ impl Views_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _AppEvents_Impl: Sized + super::Com::IDispatch_Impl { fn OnQuit(&self, application: ::core::option::Option<&_Application>) -> ::windows_core::Result<()>; fn OnDocumentOpen(&self, document: ::core::option::Option<&Document>, new: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; @@ -3801,9 +3801,9 @@ pub trait _AppEvents_Impl: Sized + super::Com::IDispatch_Impl { fn OnToolbarButtonClicked(&self) -> ::windows_core::Result<()>; fn OnListUpdated(&self, view: ::core::option::Option<&View>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _AppEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _AppEvents_Vtbl { pub const fn new, Impl: _AppEvents_Impl, const OFFSET: isize>() -> _AppEvents_Vtbl { unsafe extern "system" fn OnQuit, Impl: _AppEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, application: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3886,8 +3886,8 @@ impl _AppEvents_Vtbl { iid == &<_AppEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _Application_Impl: Sized + super::Com::IDispatch_Impl { fn Help(&self); fn Quit(&self); @@ -3902,9 +3902,9 @@ pub trait _Application_Impl: Sized + super::Com::IDispatch_Impl { fn VersionMajor(&self) -> ::windows_core::Result; fn VersionMinor(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _Application {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _Application_Vtbl { pub const fn new, Impl: _Application_Impl, const OFFSET: isize>() -> _Application_Vtbl { unsafe extern "system" fn Help, Impl: _Application_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) { @@ -4023,15 +4023,15 @@ impl _Application_Vtbl { iid == &<_Application as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _EventConnector_Impl: Sized + super::Com::IDispatch_Impl { fn ConnectTo(&self, application: ::core::option::Option<&_Application>) -> ::windows_core::Result<()>; fn Disconnect(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _EventConnector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _EventConnector_Vtbl { pub const fn new, Impl: _EventConnector_Impl, const OFFSET: isize>() -> _EventConnector_Vtbl { unsafe extern "system" fn ConnectTo, Impl: _EventConnector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, application: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/Mmc/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Mmc/mod.rs index 3127fce1ab..d58f8bde8c 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Mmc/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Mmc/mod.rs @@ -130,11 +130,14 @@ impl ContextMenu { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, indexorpath: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, indexorpath: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(indexorpath), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), indexorpath.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Count(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -147,9 +150,9 @@ impl ContextMenu { pub struct ContextMenu_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexorpath: super::Variant::VARIANT, menuitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexorpath: ::std::mem::MaybeUninit<::windows_core::VARIANT>, menuitem: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, } @@ -1404,13 +1407,13 @@ pub struct IExtendPropertySheet2_Vtbl { ::windows_core::imp::com_interface!(IExtendTaskPad, IExtendTaskPad_Vtbl, 0x8dee6511_554d_11d1_9fea_00600832db4a); ::windows_core::imp::interface_hierarchy!(IExtendTaskPad, ::windows_core::IUnknown); impl IExtendTaskPad { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn TaskNotify(&self, pdo: P0, arg: *const super::Variant::VARIANT, param2: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn TaskNotify(&self, pdo: P0, arg: *const ::windows_core::VARIANT, param2: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).TaskNotify)(::windows_core::Interface::as_raw(self), pdo.into_param().abi(), arg, param2).ok() + (::windows_core::Interface::vtable(self).TaskNotify)(::windows_core::Interface::as_raw(self), pdo.into_param().abi(), ::core::mem::transmute(arg), ::core::mem::transmute(param2)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1455,9 +1458,9 @@ impl IExtendTaskPad { #[doc(hidden)] pub struct IExtendTaskPad_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub TaskNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdo: *mut ::core::ffi::c_void, arg: *const super::Variant::VARIANT, param2: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub TaskNotify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdo: *mut ::core::ffi::c_void, arg: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, param2: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] TaskNotify: usize, #[cfg(feature = "Win32_System_Com")] pub EnumTasks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdo: *mut ::core::ffi::c_void, sztaskgroup: ::windows_core::PCWSTR, ppenumtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2102,8 +2105,6 @@ impl ISnapinProperties { { (::windows_core::Interface::vtable(self).QueryPropertyNames)(::windows_core::Interface::as_raw(self), pcallback.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn PropertiesChanged(&self, pproperties: &[MMC_SNAPIN_PROPERTY]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).PropertiesChanged)(::windows_core::Interface::as_raw(self), pproperties.len().try_into().unwrap(), ::core::mem::transmute(pproperties.as_ptr())).ok() } @@ -2117,10 +2118,7 @@ pub struct ISnapinProperties_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Initialize: usize, pub QueryPropertyNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcallback: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub PropertiesChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cproperties: i32, pproperties: *const MMC_SNAPIN_PROPERTY) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PropertiesChanged: usize, } ::windows_core::imp::com_interface!(ISnapinPropertiesCallback, ISnapinPropertiesCallback_Vtbl, 0xa50fa2e5_7e61_45eb_a8d4_9a07b3e851a8); ::windows_core::imp::interface_hierarchy!(ISnapinPropertiesCallback, ::windows_core::IUnknown); @@ -2439,16 +2437,15 @@ pub struct Properties_Vtbl { ::windows_core::imp::interface_hierarchy!(Property, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl Property { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, value: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2460,14 +2457,8 @@ impl Property { #[doc(hidden)] pub struct Property_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -2639,14 +2630,16 @@ impl SnapIns { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, snapinnameorclsid: P0, parentsnapin: super::Variant::VARIANT, properties: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, snapinnameorclsid: P0, parentsnapin: P1, properties: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), snapinnameorclsid.into_param().abi(), ::core::mem::transmute(parentsnapin), ::core::mem::transmute(properties), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), snapinnameorclsid.into_param().abi(), parentsnapin.into_param().abi(), properties.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2668,9 +2661,9 @@ pub struct SnapIns_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapinnameorclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, parentsnapin: super::Variant::VARIANT, properties: super::Variant::VARIANT, snapin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapinnameorclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, parentsnapin: ::std::mem::MaybeUninit<::windows_core::VARIANT>, properties: ::std::mem::MaybeUninit<::windows_core::VARIANT>, snapin: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, #[cfg(feature = "Win32_System_Com")] pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, snapin: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2714,11 +2707,14 @@ impl View { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ListItems)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SnapinScopeObject(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn SnapinScopeObject(&self, scopenode: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).SnapinScopeObject)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).SnapinScopeObject)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2769,37 +2765,39 @@ impl View { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsSelected)(::windows_core::Interface::as_raw(self), node.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DisplayScopeNodePropertySheet(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DisplayScopeNodePropertySheet)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode)).ok() + pub unsafe fn DisplayScopeNodePropertySheet(&self, scopenode: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DisplayScopeNodePropertySheet)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi()).ok() } pub unsafe fn DisplaySelectionPropertySheet(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DisplaySelectionPropertySheet)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyScopeNode(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CopyScopeNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode)).ok() + pub unsafe fn CopyScopeNode(&self, scopenode: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).CopyScopeNode)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi()).ok() } pub unsafe fn CopySelection(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).CopySelection)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DeleteScopeNode(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).DeleteScopeNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode)).ok() + pub unsafe fn DeleteScopeNode(&self, scopenode: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).DeleteScopeNode)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi()).ok() } pub unsafe fn DeleteSelection(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeleteSelection)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RenameScopeNode(&self, newname: P0, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn RenameScopeNode(&self, newname: P0, scopenode: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).RenameScopeNode)(::windows_core::Interface::as_raw(self), newname.into_param().abi(), ::core::mem::transmute(scopenode)).ok() + (::windows_core::Interface::vtable(self).RenameScopeNode)(::windows_core::Interface::as_raw(self), newname.into_param().abi(), scopenode.into_param().abi()).ok() } pub unsafe fn RenameSelectedItem(&self, newname: P0) -> ::windows_core::Result<()> where @@ -2807,11 +2805,14 @@ impl View { { (::windows_core::Interface::vtable(self).RenameSelectedItem)(::windows_core::Interface::as_raw(self), newname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_ScopeNodeContextMenu(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_ScopeNodeContextMenu(&self, scopenode: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_ScopeNodeContextMenu)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_ScopeNodeContextMenu)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2819,10 +2820,11 @@ impl View { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelectionContextMenu)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RefreshScopeNode(&self, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).RefreshScopeNode)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(scopenode)).ok() + pub unsafe fn RefreshScopeNode(&self, scopenode: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).RefreshScopeNode)(::windows_core::Interface::as_raw(self), scopenode.into_param().abi()).ok() } pub unsafe fn RefreshSelection(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RefreshSelection)(::windows_core::Interface::as_raw(self)).ok() @@ -2833,13 +2835,12 @@ impl View { { (::windows_core::Interface::vtable(self).ExecuteSelectionMenuItem)(::windows_core::Interface::as_raw(self), menuitempath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExecuteScopeNodeMenuItem(&self, menuitempath: P0, scopenode: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ExecuteScopeNodeMenuItem(&self, menuitempath: P0, scopenode: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).ExecuteScopeNodeMenuItem)(::windows_core::Interface::as_raw(self), menuitempath.into_param().abi(), ::core::mem::transmute(scopenode)).ok() + (::windows_core::Interface::vtable(self).ExecuteScopeNodeMenuItem)(::windows_core::Interface::as_raw(self), menuitempath.into_param().abi(), scopenode.into_param().abi()).ok() } pub unsafe fn ExecuteShellCommand(&self, command: P0, directory: P1, parameters: P2, windowstate: P3) -> ::windows_core::Result<()> where @@ -2947,9 +2948,9 @@ pub struct View_Vtbl { pub ListItems: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nodes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ListItems: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SnapinScopeObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT, scopenodeobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub SnapinScopeObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, scopenodeobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] SnapinScopeObject: usize, #[cfg(feature = "Win32_System_Com")] pub SnapinSelectionObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, selectionobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2976,44 +2977,26 @@ pub struct View_Vtbl { pub IsSelected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, node: *mut ::core::ffi::c_void, isselected: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] IsSelected: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DisplayScopeNodePropertySheet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DisplayScopeNodePropertySheet: usize, + pub DisplayScopeNodePropertySheet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DisplaySelectionPropertySheet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CopyScopeNode: usize, + pub CopyScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub CopySelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DeleteScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DeleteScopeNode: usize, + pub DeleteScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DeleteSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RenameScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newname: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RenameScopeNode: usize, + pub RenameScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newname: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RenameSelectedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_ScopeNodeContextMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT, contextmenu: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_ScopeNodeContextMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>, contextmenu: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_ScopeNodeContextMenu: usize, #[cfg(feature = "Win32_System_Com")] pub SelectionContextMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, contextmenu: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SelectionContextMenu: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RefreshScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RefreshScopeNode: usize, + pub RefreshScopeNode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub RefreshSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ExecuteSelectionMenuItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, menuitempath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExecuteScopeNodeMenuItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, menuitempath: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExecuteScopeNodeMenuItem: usize, + pub ExecuteScopeNodeMenuItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, menuitempath: ::std::mem::MaybeUninit<::windows_core::BSTR>, scopenode: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ExecuteShellCommand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, command: ::std::mem::MaybeUninit<::windows_core::BSTR>, directory: ::std::mem::MaybeUninit<::windows_core::BSTR>, parameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, windowstate: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Frame: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, frame: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4227,24 +4210,30 @@ impl ::core::default::Default for MMC_RESTORE_VIEW { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct MMC_SNAPIN_PROPERTY { pub pszPropName: ::windows_core::PCWSTR, - pub varValue: super::Variant::VARIANT, + pub varValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub eAction: MMC_PROPERTY_ACTION, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for MMC_SNAPIN_PROPERTY { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for MMC_SNAPIN_PROPERTY { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("MMC_SNAPIN_PROPERTY").field("pszPropName", &self.pszPropName).field("varValue", &self.varValue).field("eAction", &self.eAction).finish() + } +} impl ::windows_core::TypeKind for MMC_SNAPIN_PROPERTY { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for MMC_SNAPIN_PROPERTY { + fn eq(&self, other: &Self) -> bool { + self.pszPropName == other.pszPropName && self.varValue == other.varValue && self.eAction == other.eAction + } +} +impl ::core::cmp::Eq for MMC_SNAPIN_PROPERTY {} impl ::core::default::Default for MMC_SNAPIN_PROPERTY { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/System/Ole/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Ole/impl.rs index fdc547c9f3..0e13890fa5 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Ole/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Ole/impl.rs @@ -19,17 +19,17 @@ impl IAdviseSinkEx_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICanHandleException_Impl: Sized { - fn CanHandleException(&self, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CanHandleException(&self, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICanHandleException {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICanHandleException_Vtbl { pub const fn new, Impl: ICanHandleException_Impl, const OFFSET: isize>() -> ICanHandleException_Vtbl { - unsafe extern "system" fn CanHandleException, Impl: ICanHandleException_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CanHandleException, Impl: ICanHandleException_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CanHandleException(::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&pvar)).into() @@ -362,11 +362,11 @@ pub trait ICreateTypeInfo2_Impl: Sized + ICreateTypeInfo_Impl { fn DeleteVarDesc(&self, index: u32) -> ::windows_core::Result<()>; fn DeleteVarDescByMemId(&self, memid: i32) -> ::windows_core::Result<()>; fn DeleteImplType(&self, index: u32) -> ::windows_core::Result<()>; - fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetHelpStringContext(&self, dwhelpstringcontext: u32) -> ::windows_core::Result<()>; fn SetFuncHelpStringContext(&self, index: u32, dwhelpstringcontext: u32) -> ::windows_core::Result<()>; fn SetVarHelpStringContext(&self, index: u32, dwhelpstringcontext: u32) -> ::windows_core::Result<()>; @@ -403,27 +403,27 @@ impl ICreateTypeInfo2_Vtbl { let this = (*this).get_impl(); this.DeleteImplType(::core::mem::transmute_copy(&index)).into() } - unsafe extern "system" fn SetCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCustData(::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() } - unsafe extern "system" fn SetFuncCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetFuncCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetFuncCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() } - unsafe extern "system" fn SetParamCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParamCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParamCustData(::core::mem::transmute_copy(&indexfunc), ::core::mem::transmute_copy(&indexparam), ::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() } - unsafe extern "system" fn SetVarCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetVarCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetVarCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() } - unsafe extern "system" fn SetImplTypeCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetImplTypeCustData, Impl: ICreateTypeInfo2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetImplTypeCustData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() @@ -569,17 +569,17 @@ impl ICreateTypeLib_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICreateTypeLib2_Impl: Sized + ICreateTypeLib_Impl { fn DeleteTypeInfo(&self, szname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetHelpStringContext(&self, dwhelpstringcontext: u32) -> ::windows_core::Result<()>; fn SetHelpStringDll(&self, szfilename: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICreateTypeLib2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICreateTypeLib2_Vtbl { pub const fn new, Impl: ICreateTypeLib2_Impl, const OFFSET: isize>() -> ICreateTypeLib2_Vtbl { unsafe extern "system" fn DeleteTypeInfo, Impl: ICreateTypeLib2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, szname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT { @@ -587,7 +587,7 @@ impl ICreateTypeLib2_Vtbl { let this = (*this).get_impl(); this.DeleteTypeInfo(::core::mem::transmute(&szname)).into() } - unsafe extern "system" fn SetCustData, Impl: ICreateTypeLib2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetCustData, Impl: ICreateTypeLib2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetCustData(::core::mem::transmute_copy(&guid), ::core::mem::transmute_copy(&pvarval)).into() @@ -699,11 +699,11 @@ impl IDispError_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDispatchEx_Impl: Sized + super::Com::IDispatch_Impl { fn GetDispID(&self, bstrname: &::windows_core::BSTR, grfdex: u32) -> ::windows_core::Result; - fn InvokeEx(&self, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut super::Variant::VARIANT, pei: *mut super::Com::EXCEPINFO, pspcaller: ::core::option::Option<&super::Com::IServiceProvider>) -> ::windows_core::Result<()>; + fn InvokeEx(&self, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut ::windows_core::VARIANT, pei: *mut super::Com::EXCEPINFO, pspcaller: ::core::option::Option<&super::Com::IServiceProvider>) -> ::windows_core::Result<()>; fn DeleteMemberByName(&self, bstrname: &::windows_core::BSTR, grfdex: u32) -> ::windows_core::Result<()>; fn DeleteMemberByDispID(&self, id: i32) -> ::windows_core::Result<()>; fn GetMemberProperties(&self, id: i32, grfdexfetch: u32) -> ::windows_core::Result; @@ -711,9 +711,9 @@ pub trait IDispatchEx_Impl: Sized + super::Com::IDispatch_Impl { fn GetNextDispID(&self, grfdex: u32, id: i32) -> ::windows_core::Result; fn GetNameSpaceParent(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDispatchEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDispatchEx_Vtbl { pub const fn new, Impl: IDispatchEx_Impl, const OFFSET: isize>() -> IDispatchEx_Vtbl { unsafe extern "system" fn GetDispID, Impl: IDispatchEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, grfdex: u32, pid: *mut i32) -> ::windows_core::HRESULT { @@ -727,7 +727,7 @@ impl IDispatchEx_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn InvokeEx, Impl: IDispatchEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut super::Variant::VARIANT, pei: *mut super::Com::EXCEPINFO, pspcaller: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeEx, Impl: IDispatchEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pei: *mut super::Com::EXCEPINFO, pspcaller: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeEx(::core::mem::transmute_copy(&id), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdp), ::core::mem::transmute_copy(&pvarres), ::core::mem::transmute_copy(&pei), ::windows_core::from_raw_borrowed(&pspcaller)).into() @@ -1083,20 +1083,16 @@ impl IEnumOleUndoUnits_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub trait IEnumVARIANT_Impl: Sized { - fn Next(&self, celt: u32, rgvar: *mut super::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT; + fn Next(&self, celt: u32, rgvar: *mut ::windows_core::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT; fn Skip(&self, celt: u32) -> ::windows_core::HRESULT; fn Reset(&self) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumVARIANT {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl IEnumVARIANT_Vtbl { pub const fn new, Impl: IEnumVARIANT_Impl, const OFFSET: isize>() -> IEnumVARIANT_Vtbl { - unsafe extern "system" fn Next, Impl: IEnumVARIANT_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IEnumVARIANT_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&celt), ::core::mem::transmute_copy(&rgvar), ::core::mem::transmute_copy(&pceltfetched)) @@ -1379,12 +1375,12 @@ impl IFont_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFontDisp_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFontDisp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFontDisp_Vtbl { pub const fn new, Impl: IFontDisp_Impl, const OFFSET: isize>() -> IFontDisp_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -1393,12 +1389,12 @@ impl IFontDisp_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFontEventsDisp_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFontEventsDisp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFontEventsDisp_Vtbl { pub const fn new, Impl: IFontEventsDisp_Impl, const OFFSET: isize>() -> IFontEventsDisp_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -1753,15 +1749,11 @@ impl IOleClientSite_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub trait IOleCommandTarget_Impl: Sized { fn QueryStatus(&self, pguidcmdgroup: *const ::windows_core::GUID, ccmds: u32, prgcmds: *mut OLECMD, pcmdtext: *mut OLECMDTEXT) -> ::windows_core::Result<()>; - fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const super::Variant::VARIANT, pvaout: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const ::windows_core::VARIANT, pvaout: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IOleCommandTarget {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl IOleCommandTarget_Vtbl { pub const fn new, Impl: IOleCommandTarget_Impl, const OFFSET: isize>() -> IOleCommandTarget_Vtbl { unsafe extern "system" fn QueryStatus, Impl: IOleCommandTarget_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ccmds: u32, prgcmds: *mut OLECMD, pcmdtext: *mut OLECMDTEXT) -> ::windows_core::HRESULT { @@ -1769,7 +1761,7 @@ impl IOleCommandTarget_Vtbl { let this = (*this).get_impl(); this.QueryStatus(::core::mem::transmute_copy(&pguidcmdgroup), ::core::mem::transmute_copy(&ccmds), ::core::mem::transmute_copy(&prgcmds), ::core::mem::transmute_copy(&pcmdtext)).into() } - unsafe extern "system" fn Exec, Impl: IOleCommandTarget_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const super::Variant::VARIANT, pvaout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Exec, Impl: IOleCommandTarget_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Exec(::core::mem::transmute_copy(&pguidcmdgroup), ::core::mem::transmute_copy(&ncmdid), ::core::mem::transmute_copy(&ncmdexecopt), ::core::mem::transmute_copy(&pvain), ::core::mem::transmute_copy(&pvaout)).into() @@ -3567,17 +3559,13 @@ impl IParseDisplayName_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub trait IPerPropertyBrowsing_Impl: Sized { fn GetDisplayString(&self, dispid: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn MapPropertyToPage(&self, dispid: i32) -> ::windows_core::Result<::windows_core::GUID>; fn GetPredefinedStrings(&self, dispid: i32, pcastringsout: *mut CALPOLESTR, pcacookiesout: *mut CADWORD) -> ::windows_core::Result<()>; - fn GetPredefinedValue(&self, dispid: i32, dwcookie: u32) -> ::windows_core::Result; + fn GetPredefinedValue(&self, dispid: i32, dwcookie: u32) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPerPropertyBrowsing {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl IPerPropertyBrowsing_Vtbl { pub const fn new, Impl: IPerPropertyBrowsing_Impl, const OFFSET: isize>() -> IPerPropertyBrowsing_Vtbl { unsafe extern "system" fn GetDisplayString, Impl: IPerPropertyBrowsing_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispid: i32, pbstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3607,7 +3595,7 @@ impl IPerPropertyBrowsing_Vtbl { let this = (*this).get_impl(); this.GetPredefinedStrings(::core::mem::transmute_copy(&dispid), ::core::mem::transmute_copy(&pcastringsout), ::core::mem::transmute_copy(&pcacookiesout)).into() } - unsafe extern "system" fn GetPredefinedValue, Impl: IPerPropertyBrowsing_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispid: i32, dwcookie: u32, pvarout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPredefinedValue, Impl: IPerPropertyBrowsing_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispid: i32, dwcookie: u32, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPredefinedValue(::core::mem::transmute_copy(&dispid), ::core::mem::transmute_copy(&dwcookie)) { @@ -4051,12 +4039,12 @@ impl IPicture2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPictureDisp_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPictureDisp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPictureDisp_Vtbl { pub const fn new, Impl: IPictureDisp_Impl, const OFFSET: isize>() -> IPictureDisp_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -4573,8 +4561,8 @@ impl IQuickActivate_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRecordInfo_Impl: Sized { fn RecordInit(&self, pvnew: *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn RecordClear(&self, pvexisting: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; @@ -4583,19 +4571,19 @@ pub trait IRecordInfo_Impl: Sized { fn GetName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetSize(&self) -> ::windows_core::Result; fn GetTypeInfo(&self) -> ::windows_core::Result; - fn GetField(&self, pvdata: *const ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn GetFieldNoCopy(&self, pvdata: *const ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *mut super::Variant::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn PutField(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn PutFieldNoCopy(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetField(&self, pvdata: *const ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetFieldNoCopy(&self, pvdata: *const ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *mut ::windows_core::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; + fn PutField(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn PutFieldNoCopy(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: &::windows_core::PCWSTR, pvarfield: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetFieldNames(&self, pcnames: *mut u32, rgbstrnames: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsMatchingType(&self, precordinfo: ::core::option::Option<&IRecordInfo>) -> super::super::Foundation::BOOL; fn RecordCreate(&self) -> *mut ::core::ffi::c_void; fn RecordCreateCopy(&self, pvsource: *const ::core::ffi::c_void, ppvdest: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn RecordDestroy(&self, pvrecord: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRecordInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRecordInfo_Vtbl { pub const fn new, Impl: IRecordInfo_Impl, const OFFSET: isize>() -> IRecordInfo_Vtbl { unsafe extern "system" fn RecordInit, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvnew: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4657,7 +4645,7 @@ impl IRecordInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetField, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetField, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetField(::core::mem::transmute_copy(&pvdata), ::core::mem::transmute(&szfieldname)) { @@ -4668,17 +4656,17 @@ impl IRecordInfo_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetFieldNoCopy, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut super::Variant::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFieldNoCopy, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetFieldNoCopy(::core::mem::transmute_copy(&pvdata), ::core::mem::transmute(&szfieldname), ::core::mem::transmute_copy(&pvarfield), ::core::mem::transmute_copy(&ppvdatacarray)).into() } - unsafe extern "system" fn PutField, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutField, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutField(::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pvdata), ::core::mem::transmute(&szfieldname), ::core::mem::transmute_copy(&pvarfield)).into() } - unsafe extern "system" fn PutFieldNoCopy, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutFieldNoCopy, Impl: IRecordInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutFieldNoCopy(::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pvdata), ::core::mem::transmute(&szfieldname), ::core::mem::transmute_copy(&pvarfield)).into() @@ -4893,17 +4881,13 @@ impl ITypeMarshal_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub trait IVBFormat_Impl: Sized { - fn Format(&self, vdata: *mut super::Variant::VARIANT, bstrformat: &::windows_core::BSTR, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::Result<()>; + fn Format(&self, vdata: *mut ::windows_core::VARIANT, bstrformat: &::windows_core::BSTR, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IVBFormat {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl IVBFormat_Vtbl { pub const fn new, Impl: IVBFormat_Impl, const OFFSET: isize>() -> IVBFormat_Vtbl { - unsafe extern "system" fn Format, Impl: IVBFormat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdata: *mut super::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::HRESULT { + unsafe extern "system" fn Format, Impl: IVBFormat_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Format(::core::mem::transmute_copy(&vdata), ::core::mem::transmute(&bstrformat), ::core::mem::transmute_copy(&lpbuffer), ::core::mem::transmute_copy(&cb), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&sfirstdayofweek), ::core::mem::transmute_copy(&sfirstweekofyear), ::core::mem::transmute_copy(&rcb)).into() @@ -4941,17 +4925,17 @@ impl IVBGetControl_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Variant\"`"] +#[cfg(feature = "Win32_System_Variant")] pub trait IVariantChangeType_Impl: Sized { - fn ChangeType(&self, pvardst: *mut super::Variant::VARIANT, pvarsrc: *const super::Variant::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::Result<()>; + fn ChangeType(&self, pvardst: *mut ::windows_core::VARIANT, pvarsrc: *const ::windows_core::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::RuntimeName for IVariantChangeType {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl IVariantChangeType_Vtbl { pub const fn new, Impl: IVariantChangeType_Impl, const OFFSET: isize>() -> IVariantChangeType_Vtbl { - unsafe extern "system" fn ChangeType, Impl: IVariantChangeType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardst: *mut super::Variant::VARIANT, pvarsrc: *const super::Variant::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::HRESULT { + unsafe extern "system" fn ChangeType, Impl: IVariantChangeType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvardst: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarsrc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ChangeType(::core::mem::transmute_copy(&pvardst), ::core::mem::transmute_copy(&pvarsrc), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&vtnew)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/Ole/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Ole/mod.rs index ff1a513dd6..6b78c9fdad 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Ole/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Ole/mod.rs @@ -6,8 +6,8 @@ pub unsafe fn BstrFromVector(psa: *const super::Com::SAFEARRAY) -> ::windows_cor let mut result__ = ::std::mem::zeroed(); BstrFromVector(psa, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] pub unsafe fn ClearCustData(pcustdata: *mut super::Com::CUSTDATA) { ::windows_targets::link!("oleaut32.dll" "system" fn ClearCustData(pcustdata : *mut super::Com:: CUSTDATA)); @@ -68,8 +68,8 @@ where #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn DispCallFunc(pvinstance: ::core::option::Option<*const ::core::ffi::c_void>, ovft: usize, cc: super::Com::CALLCONV, vtreturn: super::Variant::VARENUM, cactuals: u32, prgvt: *const u16, prgpvarg: *const *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn DispCallFunc(pvinstance : *const ::core::ffi::c_void, ovft : usize, cc : super::Com:: CALLCONV, vtreturn : super::Variant:: VARENUM, cactuals : u32, prgvt : *const u16, prgpvarg : *const *const super::Variant:: VARIANT, pvargresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn DispCallFunc(pvinstance: ::core::option::Option<*const ::core::ffi::c_void>, ovft: usize, cc: super::Com::CALLCONV, vtreturn: super::Variant::VARENUM, cactuals: u32, prgvt: *const u16, prgpvarg: *const *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn DispCallFunc(pvinstance : *const ::core::ffi::c_void, ovft : usize, cc : super::Com:: CALLCONV, vtreturn : super::Variant:: VARENUM, cactuals : u32, prgvt : *const u16, prgpvarg : *const *const ::windows_core::VARIANT, pvargresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); DispCallFunc(::core::mem::transmute(pvinstance.unwrap_or(::std::ptr::null())), ovft, cc, vtreturn, cactuals, prgvt, prgpvarg, &mut result__).from_abi(result__) } @@ -86,19 +86,19 @@ where #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn DispGetParam(pdispparams: *const super::Com::DISPPARAMS, position: u32, vttarg: super::Variant::VARENUM, pvarresult: *mut super::Variant::VARIANT, puargerr: ::core::option::Option<*mut u32>) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn DispGetParam(pdispparams : *const super::Com:: DISPPARAMS, position : u32, vttarg : super::Variant:: VARENUM, pvarresult : *mut super::Variant:: VARIANT, puargerr : *mut u32) -> ::windows_core::HRESULT); - DispGetParam(pdispparams, position, vttarg, pvarresult, ::core::mem::transmute(puargerr.unwrap_or(::std::ptr::null_mut()))).ok() +pub unsafe fn DispGetParam(pdispparams: *const super::Com::DISPPARAMS, position: u32, vttarg: super::Variant::VARENUM, pvarresult: *mut ::windows_core::VARIANT, puargerr: ::core::option::Option<*mut u32>) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn DispGetParam(pdispparams : *const super::Com:: DISPPARAMS, position : u32, vttarg : super::Variant:: VARENUM, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, puargerr : *mut u32) -> ::windows_core::HRESULT); + DispGetParam(pdispparams, position, vttarg, ::core::mem::transmute(pvarresult), ::core::mem::transmute(puargerr.unwrap_or(::std::ptr::null_mut()))).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn DispInvoke(_this: *mut ::core::ffi::c_void, ptinfo: P0, dispidmember: i32, wflags: u16, pparams: *mut super::Com::DISPPARAMS, pvarresult: *mut super::Variant::VARIANT, pexcepinfo: *mut super::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> +pub unsafe fn DispInvoke(_this: *mut ::core::ffi::c_void, ptinfo: P0, dispidmember: i32, wflags: u16, pparams: *mut super::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("oleaut32.dll" "system" fn DispInvoke(_this : *mut ::core::ffi::c_void, ptinfo : * mut::core::ffi::c_void, dispidmember : i32, wflags : u16, pparams : *mut super::Com:: DISPPARAMS, pvarresult : *mut super::Variant:: VARIANT, pexcepinfo : *mut super::Com:: EXCEPINFO, puargerr : *mut u32) -> ::windows_core::HRESULT); - DispInvoke(_this, ptinfo.into_param().abi(), dispidmember, wflags, pparams, pvarresult, pexcepinfo, puargerr).ok() + ::windows_targets::link!("oleaut32.dll" "system" fn DispInvoke(_this : *mut ::core::ffi::c_void, ptinfo : * mut::core::ffi::c_void, dispidmember : i32, wflags : u16, pparams : *mut super::Com:: DISPPARAMS, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pexcepinfo : *mut super::Com:: EXCEPINFO, puargerr : *mut u32) -> ::windows_core::HRESULT); + DispInvoke(_this, ptinfo.into_param().abi(), dispidmember, wflags, pparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -650,21 +650,27 @@ where ::windows_targets::link!("oleaut32.dll" "system" fn OleLoadPictureEx(lpstream : * mut::core::ffi::c_void, lsize : i32, frunmode : super::super::Foundation:: BOOL, riid : *const ::windows_core::GUID, xsizedesired : u32, ysizedesired : u32, dwflags : LOAD_PICTURE_FLAGS, lplpvobj : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); OleLoadPictureEx(lpstream.into_param().abi(), lsize, frunmode.into_param().abi(), riid, xsizedesired, ysizedesired, dwflags, lplpvobj).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn OleLoadPictureFile(varfilename: super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn OleLoadPictureFile(varfilename : super::Variant:: VARIANT, lplpdisppicture : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); +pub unsafe fn OleLoadPictureFile(varfilename: P0) -> ::windows_core::Result +where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, +{ + ::windows_targets::link!("oleaut32.dll" "system" fn OleLoadPictureFile(varfilename : ::std::mem::MaybeUninit <::windows_core::VARIANT >, lplpdisppicture : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - OleLoadPictureFile(::core::mem::transmute(varfilename), &mut result__).from_abi(result__) + OleLoadPictureFile(varfilename.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn OleLoadPictureFileEx(varfilename: super::Variant::VARIANT, xsizedesired: u32, ysizedesired: u32, dwflags: LOAD_PICTURE_FLAGS) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn OleLoadPictureFileEx(varfilename : super::Variant:: VARIANT, xsizedesired : u32, ysizedesired : u32, dwflags : LOAD_PICTURE_FLAGS, lplpdisppicture : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); +pub unsafe fn OleLoadPictureFileEx(varfilename: P0, xsizedesired: u32, ysizedesired: u32, dwflags: LOAD_PICTURE_FLAGS) -> ::windows_core::Result +where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, +{ + ::windows_targets::link!("oleaut32.dll" "system" fn OleLoadPictureFileEx(varfilename : ::std::mem::MaybeUninit <::windows_core::VARIANT >, xsizedesired : u32, ysizedesired : u32, dwflags : LOAD_PICTURE_FLAGS, lplpdisppicture : *mut * mut::core::ffi::c_void) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - OleLoadPictureFileEx(::core::mem::transmute(varfilename), xsizedesired, ysizedesired, dwflags, &mut result__).from_abi(result__) + OleLoadPictureFileEx(varfilename.into_param().abi(), xsizedesired, ysizedesired, dwflags, &mut result__).from_abi(result__) } #[inline] pub unsafe fn OleLoadPicturePath(szurlorpath: P0, punkcaller: P1, dwreserved: u32, clrreserved: u32, riid: *const ::windows_core::GUID, ppvret: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> @@ -1340,29 +1346,23 @@ pub unsafe fn UnRegisterTypeLibForUser(libid: *const ::windows_core::GUID, wmajo ::windows_targets::link!("oleaut32.dll" "system" fn UnRegisterTypeLibForUser(libid : *const ::windows_core::GUID, wmajorvernum : u16, wminorvernum : u16, lcid : u32, syskind : super::Com:: SYSKIND) -> ::windows_core::HRESULT); UnRegisterTypeLibForUser(libid, wmajorvernum, wminorvernum, lcid, syskind).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarAbs(pvarin: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarAbs(pvarin : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarAbs(pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarAbs(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarAbs(pvarin, &mut result__).from_abi(result__) + VarAbs(::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarAdd(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarAdd(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarAdd(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarAdd(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarAdd(pvarleft, pvarright, &mut result__).from_abi(result__) + VarAdd(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarAnd(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarAnd(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarAnd(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarAnd(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarAnd(pvarleft, pvarright, &mut result__).from_abi(result__) + VarAnd(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1583,20 +1583,16 @@ pub unsafe fn VarBstrFromUI8(ui64in: u64, lcid: u32, dwflags: u32) -> ::windows_ let mut result__ = ::std::mem::zeroed(); VarBstrFromUI8(ui64in, lcid, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarCat(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarCat(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarCat(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarCat(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarCat(pvarleft, pvarright, &mut result__).from_abi(result__) + VarCat(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarCmp(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT, lcid: u32, dwflags: u32) -> VARCMP { - ::windows_targets::link!("oleaut32.dll" "system" fn VarCmp(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, lcid : u32, dwflags : u32) -> VARCMP); - VarCmp(pvarleft, pvarright, lcid, dwflags) +pub unsafe fn VarCmp(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT, lcid: u32, dwflags: u32) -> VARCMP { + ::windows_targets::link!("oleaut32.dll" "system" fn VarCmp(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, lcid : u32, dwflags : u32) -> VARCMP); + VarCmp(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), lcid, dwflags) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2103,82 +2099,64 @@ pub unsafe fn VarDecSub(pdecleft: *const super::super::Foundation::DECIMAL, pdec let mut result__ = ::std::mem::zeroed(); VarDecSub(pdecleft, pdecright, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarDiv(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarDiv(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarDiv(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarDiv(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarDiv(pvarleft, pvarright, &mut result__).from_abi(result__) + VarDiv(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarEqv(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarEqv(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarEqv(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarEqv(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarEqv(pvarleft, pvarright, &mut result__).from_abi(result__) + VarEqv(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFix(pvarin: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFix(pvarin : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarFix(pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarFix(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFix(pvarin, &mut result__).from_abi(result__) + VarFix(::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormat(pvarin: *const super::Variant::VARIANT, pstrformat: P0, ifirstday: VARFORMAT_FIRST_DAY, ifirstweek: VARFORMAT_FIRST_WEEK, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> +pub unsafe fn VarFormat(pvarin: *const ::windows_core::VARIANT, pstrformat: P0, ifirstday: VARFORMAT_FIRST_DAY, ifirstweek: VARFORMAT_FIRST_WEEK, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormat(pvarin : *const super::Variant:: VARIANT, pstrformat : ::windows_core::PCWSTR, ifirstday : VARFORMAT_FIRST_DAY, ifirstweek : VARFORMAT_FIRST_WEEK, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormat(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pstrformat : ::windows_core::PCWSTR, ifirstday : VARFORMAT_FIRST_DAY, ifirstweek : VARFORMAT_FIRST_WEEK, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFormat(pvarin, pstrformat.into_param().abi(), ifirstday, ifirstweek, dwflags, &mut result__).from_abi(result__) + VarFormat(::core::mem::transmute(pvarin), pstrformat.into_param().abi(), ifirstday, ifirstweek, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormatCurrency(pvarin: *const super::Variant::VARIANT, inumdig: i32, iinclead: i32, iuseparens: i32, igroup: i32, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatCurrency(pvarin : *const super::Variant:: VARIANT, inumdig : i32, iinclead : i32, iuseparens : i32, igroup : i32, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); +pub unsafe fn VarFormatCurrency(pvarin: *const ::windows_core::VARIANT, inumdig: i32, iinclead: i32, iuseparens: i32, igroup: i32, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatCurrency(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, inumdig : i32, iinclead : i32, iuseparens : i32, igroup : i32, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFormatCurrency(pvarin, inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) + VarFormatCurrency(::core::mem::transmute(pvarin), inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormatDateTime(pvarin: *const super::Variant::VARIANT, inamedformat: VARFORMAT_NAMED_FORMAT, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatDateTime(pvarin : *const super::Variant:: VARIANT, inamedformat : VARFORMAT_NAMED_FORMAT, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); +pub unsafe fn VarFormatDateTime(pvarin: *const ::windows_core::VARIANT, inamedformat: VARFORMAT_NAMED_FORMAT, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatDateTime(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, inamedformat : VARFORMAT_NAMED_FORMAT, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFormatDateTime(pvarin, inamedformat, dwflags, &mut result__).from_abi(result__) + VarFormatDateTime(::core::mem::transmute(pvarin), inamedformat, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormatFromTokens(pvarin: *const super::Variant::VARIANT, pstrformat: P0, pbtokcur: *const u8, dwflags: u32, pbstrout: *mut ::windows_core::BSTR, lcid: u32) -> ::windows_core::Result<()> +pub unsafe fn VarFormatFromTokens(pvarin: *const ::windows_core::VARIANT, pstrformat: P0, pbtokcur: *const u8, dwflags: u32, pbstrout: *mut ::windows_core::BSTR, lcid: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatFromTokens(pvarin : *const super::Variant:: VARIANT, pstrformat : ::windows_core::PCWSTR, pbtokcur : *const u8, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >, lcid : u32) -> ::windows_core::HRESULT); - VarFormatFromTokens(pvarin, pstrformat.into_param().abi(), pbtokcur, dwflags, ::core::mem::transmute(pbstrout), lcid).ok() + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatFromTokens(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pstrformat : ::windows_core::PCWSTR, pbtokcur : *const u8, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >, lcid : u32) -> ::windows_core::HRESULT); + VarFormatFromTokens(::core::mem::transmute(pvarin), pstrformat.into_param().abi(), pbtokcur, dwflags, ::core::mem::transmute(pbstrout), lcid).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormatNumber(pvarin: *const super::Variant::VARIANT, inumdig: i32, iinclead: VARFORMAT_LEADING_DIGIT, iuseparens: VARFORMAT_PARENTHESES, igroup: VARFORMAT_GROUP, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatNumber(pvarin : *const super::Variant:: VARIANT, inumdig : i32, iinclead : VARFORMAT_LEADING_DIGIT, iuseparens : VARFORMAT_PARENTHESES, igroup : VARFORMAT_GROUP, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); +pub unsafe fn VarFormatNumber(pvarin: *const ::windows_core::VARIANT, inumdig: i32, iinclead: VARFORMAT_LEADING_DIGIT, iuseparens: VARFORMAT_PARENTHESES, igroup: VARFORMAT_GROUP, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatNumber(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, inumdig : i32, iinclead : VARFORMAT_LEADING_DIGIT, iuseparens : VARFORMAT_PARENTHESES, igroup : VARFORMAT_GROUP, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFormatNumber(pvarin, inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) + VarFormatNumber(::core::mem::transmute(pvarin), inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarFormatPercent(pvarin: *const super::Variant::VARIANT, inumdig: i32, iinclead: VARFORMAT_LEADING_DIGIT, iuseparens: VARFORMAT_PARENTHESES, igroup: VARFORMAT_GROUP, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { - ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatPercent(pvarin : *const super::Variant:: VARIANT, inumdig : i32, iinclead : VARFORMAT_LEADING_DIGIT, iuseparens : VARFORMAT_PARENTHESES, igroup : VARFORMAT_GROUP, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); +pub unsafe fn VarFormatPercent(pvarin: *const ::windows_core::VARIANT, inumdig: i32, iinclead: VARFORMAT_LEADING_DIGIT, iuseparens: VARFORMAT_PARENTHESES, igroup: VARFORMAT_GROUP, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarFormatPercent(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, inumdig : i32, iinclead : VARFORMAT_LEADING_DIGIT, iuseparens : VARFORMAT_PARENTHESES, igroup : VARFORMAT_GROUP, dwflags : u32, pbstrout : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarFormatPercent(pvarin, inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) + VarFormatPercent(::core::mem::transmute(pvarin), inumdig, iinclead, iuseparens, igroup, dwflags, &mut result__).from_abi(result__) } #[inline] pub unsafe fn VarI1FromBool(boolin: P0, pcout: ::windows_core::PSTR) -> ::windows_core::Result<()> @@ -2570,37 +2548,29 @@ pub unsafe fn VarI8FromUI8(ui64in: u64) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); VarI8FromUI8(ui64in, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarIdiv(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarIdiv(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarIdiv(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarIdiv(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarIdiv(pvarleft, pvarright, &mut result__).from_abi(result__) + VarIdiv(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarImp(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarImp(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarImp(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarImp(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarImp(pvarleft, pvarright, &mut result__).from_abi(result__) + VarImp(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarInt(pvarin: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarInt(pvarin : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarInt(pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarInt(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarInt(pvarin, &mut result__).from_abi(result__) + VarInt(::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarMod(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarMod(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarMod(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarMod(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarMod(pvarleft, pvarright, &mut result__).from_abi(result__) + VarMod(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[inline] pub unsafe fn VarMonthName(imonth: i32, fabbrev: i32, dwflags: u32) -> ::windows_core::Result<::windows_core::BSTR> { @@ -2608,45 +2578,35 @@ pub unsafe fn VarMonthName(imonth: i32, fabbrev: i32, dwflags: u32) -> ::windows let mut result__ = ::std::mem::zeroed(); VarMonthName(imonth, fabbrev, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarMul(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarMul(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarMul(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarMul(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarMul(pvarleft, pvarright, &mut result__).from_abi(result__) + VarMul(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarNeg(pvarin: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarNeg(pvarin : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarNeg(pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarNeg(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarNeg(pvarin, &mut result__).from_abi(result__) + VarNeg(::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarNot(pvarin: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarNot(pvarin : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarNot(pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarNot(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarNot(pvarin, &mut result__).from_abi(result__) + VarNot(::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarNumFromParseNum(pnumprs: *const NUMPARSE, rgbdig: *const u8, dwvtbits: u32) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarNumFromParseNum(pnumprs : *const NUMPARSE, rgbdig : *const u8, dwvtbits : u32, pvar : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarNumFromParseNum(pnumprs: *const NUMPARSE, rgbdig: *const u8, dwvtbits: u32) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarNumFromParseNum(pnumprs : *const NUMPARSE, rgbdig : *const u8, dwvtbits : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); VarNumFromParseNum(pnumprs, rgbdig, dwvtbits, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarOr(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarOr(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarOr(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarOr(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarOr(pvarleft, pvarright, &mut result__).from_abi(result__) + VarOr(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[inline] pub unsafe fn VarParseNumFromStr(strin: P0, lcid: u32, dwflags: u32, pnumprs: *mut NUMPARSE, rgbdig: *mut u8) -> ::windows_core::Result<()> @@ -2656,13 +2616,11 @@ where ::windows_targets::link!("oleaut32.dll" "system" fn VarParseNumFromStr(strin : ::windows_core::PCWSTR, lcid : u32, dwflags : u32, pnumprs : *mut NUMPARSE, rgbdig : *mut u8) -> ::windows_core::HRESULT); VarParseNumFromStr(strin.into_param().abi(), lcid, dwflags, pnumprs, rgbdig).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarPow(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarPow(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarPow(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarPow(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarPow(pvarleft, pvarright, &mut result__).from_abi(result__) + VarPow(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[inline] pub unsafe fn VarR4CmpR8(fltleft: f32, dblright: f64) -> VARCMP { @@ -2884,21 +2842,17 @@ pub unsafe fn VarR8Round(dblin: f64, cdecimals: i32) -> ::windows_core::Result ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarRound(pvarin : *const super::Variant:: VARIANT, cdecimals : i32, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarRound(pvarin: *const ::windows_core::VARIANT, cdecimals: i32) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarRound(pvarin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, cdecimals : i32, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarRound(pvarin, cdecimals, &mut result__).from_abi(result__) + VarRound(::core::mem::transmute(pvarin), cdecimals, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarSub(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarSub(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarSub(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarSub(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarSub(pvarleft, pvarright, &mut result__).from_abi(result__) + VarSub(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[inline] pub unsafe fn VarTokenizeFormatString(pstrformat: P0, rgbtok: &mut [u8], ifirstday: VARFORMAT_FIRST_DAY, ifirstweek: VARFORMAT_FIRST_WEEK, lcid: u32, pcbactual: ::core::option::Option<*const i32>) -> ::windows_core::Result<()> @@ -3324,13 +3278,11 @@ pub unsafe fn VarWeekdayName(iweekday: i32, fabbrev: i32, ifirstday: i32, dwflag let mut result__ = ::std::mem::zeroed(); VarWeekdayName(iweekday, fabbrev, ifirstday, dwflags, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn VarXor(pvarleft: *const super::Variant::VARIANT, pvarright: *const super::Variant::VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("oleaut32.dll" "system" fn VarXor(pvarleft : *const super::Variant:: VARIANT, pvarright : *const super::Variant:: VARIANT, pvarresult : *mut super::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn VarXor(pvarleft: *const ::windows_core::VARIANT, pvarright: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("oleaut32.dll" "system" fn VarXor(pvarleft : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarright : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarresult : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VarXor(pvarleft, pvarright, &mut result__).from_abi(result__) + VarXor(::core::mem::transmute(pvarleft), ::core::mem::transmute(pvarright), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3396,19 +3348,19 @@ pub struct IAdviseSinkEx_Vtbl { ::windows_core::imp::com_interface!(ICanHandleException, ICanHandleException_Vtbl, 0xc5598e60_b307_11d1_b27d_006008c3fbfb); ::windows_core::imp::interface_hierarchy!(ICanHandleException, ::windows_core::IUnknown); impl ICanHandleException { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn CanHandleException(&self, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CanHandleException)(::windows_core::Interface::as_raw(self), pexcepinfo, pvar).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CanHandleException(&self, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).CanHandleException)(::windows_core::Interface::as_raw(self), pexcepinfo, ::core::mem::transmute(pvar)).ok() } } #[repr(C)] #[doc(hidden)] pub struct ICanHandleException_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub CanHandleException: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CanHandleException: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pexcepinfo: *const super::Com::EXCEPINFO, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CanHandleException: usize, } #[cfg(feature = "Win32_System_Com")] @@ -3820,30 +3772,20 @@ impl ICreateTypeInfo2 { pub unsafe fn DeleteImplType(&self, index: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeleteImplType)(::windows_core::Interface::as_raw(self), index).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCustData)(::windows_core::Interface::as_raw(self), guid, pvarval).ok() + pub unsafe fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetCustData)(::windows_core::Interface::as_raw(self), guid, ::core::mem::transmute(pvarval)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetFuncCustData)(::windows_core::Interface::as_raw(self), index, guid, pvarval).ok() + pub unsafe fn SetFuncCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetFuncCustData)(::windows_core::Interface::as_raw(self), index, guid, ::core::mem::transmute(pvarval)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetParamCustData)(::windows_core::Interface::as_raw(self), indexfunc, indexparam, guid, pvarval).ok() + pub unsafe fn SetParamCustData(&self, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetParamCustData)(::windows_core::Interface::as_raw(self), indexfunc, indexparam, guid, ::core::mem::transmute(pvarval)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetVarCustData)(::windows_core::Interface::as_raw(self), index, guid, pvarval).ok() + pub unsafe fn SetVarCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetVarCustData)(::windows_core::Interface::as_raw(self), index, guid, ::core::mem::transmute(pvarval)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetImplTypeCustData)(::windows_core::Interface::as_raw(self), index, guid, pvarval).ok() + pub unsafe fn SetImplTypeCustData(&self, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetImplTypeCustData)(::windows_core::Interface::as_raw(self), index, guid, ::core::mem::transmute(pvarval)).ok() } pub unsafe fn SetHelpStringContext(&self, dwhelpstringcontext: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetHelpStringContext)(::windows_core::Interface::as_raw(self), dwhelpstringcontext).ok() @@ -3876,26 +3818,11 @@ pub struct ICreateTypeInfo2_Vtbl { pub DeleteVarDesc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32) -> ::windows_core::HRESULT, pub DeleteVarDescByMemId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, memid: i32) -> ::windows_core::HRESULT, pub DeleteImplType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetCustData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetFuncCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetFuncCustData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetParamCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetParamCustData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetVarCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetVarCustData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetImplTypeCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetImplTypeCustData: usize, + pub SetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetFuncCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetParamCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, indexfunc: u32, indexparam: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetVarCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetImplTypeCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetHelpStringContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwhelpstringcontext: u32) -> ::windows_core::HRESULT, pub SetFuncHelpStringContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, dwhelpstringcontext: u32) -> ::windows_core::HRESULT, pub SetVarHelpStringContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: u32, dwhelpstringcontext: u32) -> ::windows_core::HRESULT, @@ -4023,10 +3950,8 @@ impl ICreateTypeLib2 { { (::windows_core::Interface::vtable(self).DeleteTypeInfo)(::windows_core::Interface::as_raw(self), szname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetCustData)(::windows_core::Interface::as_raw(self), guid, pvarval).ok() + pub unsafe fn SetCustData(&self, guid: *const ::windows_core::GUID, pvarval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetCustData)(::windows_core::Interface::as_raw(self), guid, ::core::mem::transmute(pvarval)).ok() } pub unsafe fn SetHelpStringContext(&self, dwhelpstringcontext: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetHelpStringContext)(::windows_core::Interface::as_raw(self), dwhelpstringcontext).ok() @@ -4043,10 +3968,7 @@ impl ICreateTypeLib2 { pub struct ICreateTypeLib2_Vtbl { pub base__: ICreateTypeLib_Vtbl, pub DeleteTypeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, szname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub SetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - SetCustData: usize, + pub SetCustData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *const ::windows_core::GUID, pvarval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetHelpStringContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwhelpstringcontext: u32) -> ::windows_core::HRESULT, pub SetHelpStringDll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, szfilename: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, } @@ -4106,9 +4028,9 @@ impl IDispatchEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDispID)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), grfdex, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeEx(&self, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: ::core::option::Option<*mut super::Variant::VARIANT>, pei: ::core::option::Option<*mut super::Com::EXCEPINFO>, pspcaller: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn InvokeEx(&self, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: ::core::option::Option<*mut ::windows_core::VARIANT>, pei: ::core::option::Option<*mut super::Com::EXCEPINFO>, pspcaller: P0) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { @@ -4146,9 +4068,9 @@ impl IDispatchEx { pub struct IDispatchEx_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub GetDispID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, grfdex: u32, pid: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub InvokeEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut super::Variant::VARIANT, pei: *mut super::Com::EXCEPINFO, pspcaller: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub InvokeEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32, lcid: u32, wflags: u16, pdp: *const super::Com::DISPPARAMS, pvarres: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pei: *mut super::Com::EXCEPINFO, pspcaller: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] InvokeEx: usize, pub DeleteMemberByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, grfdex: u32) -> ::windows_core::HRESULT, pub DeleteMemberByDispID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: i32) -> ::windows_core::HRESULT, @@ -4355,9 +4277,7 @@ pub struct IEnumOleUndoUnits_Vtbl { ::windows_core::imp::com_interface!(IEnumVARIANT, IEnumVARIANT_Vtbl, 0x00020404_0000_0000_c000_000000000046); ::windows_core::imp::interface_hierarchy!(IEnumVARIANT, ::windows_core::IUnknown); impl IEnumVARIANT { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, rgvar: &mut [super::Variant::VARIANT], pceltfetched: *mut u32) -> ::windows_core::HRESULT { + pub unsafe fn Next(&self, rgvar: &mut [::windows_core::VARIANT], pceltfetched: *mut u32) -> ::windows_core::HRESULT { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvar.len().try_into().unwrap(), ::core::mem::transmute(rgvar.as_ptr()), pceltfetched) } pub unsafe fn Skip(&self, celt: u32) -> ::windows_core::HRESULT { @@ -4375,10 +4295,7 @@ impl IEnumVARIANT { #[doc(hidden)] pub struct IEnumVARIANT_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut super::Variant::VARIANT, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pceltfetched: *mut u32) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4903,10 +4820,8 @@ impl IOleCommandTarget { pub unsafe fn QueryStatus(&self, pguidcmdgroup: *const ::windows_core::GUID, ccmds: u32, prgcmds: *mut OLECMD, pcmdtext: *mut OLECMDTEXT) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).QueryStatus)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ccmds, prgcmds, pcmdtext).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const super::Variant::VARIANT, pvaout: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Exec)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ncmdid, ncmdexecopt, pvain, pvaout).ok() + pub unsafe fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const ::windows_core::VARIANT, pvaout: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Exec)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ncmdid, ncmdexecopt, ::core::mem::transmute(pvain), ::core::mem::transmute(pvaout)).ok() } } #[repr(C)] @@ -4914,10 +4829,7 @@ impl IOleCommandTarget { pub struct IOleCommandTarget_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub QueryStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ccmds: u32, prgcmds: *mut OLECMD, pcmdtext: *mut OLECMDTEXT) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub Exec: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const super::Variant::VARIANT, pvaout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - Exec: usize, + pub Exec: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IOleContainer, IOleContainer_Vtbl, 0x0000011b_0000_0000_c000_000000000046); ::windows_core::imp::interface_hierarchy!(IOleContainer, ::windows_core::IUnknown, IParseDisplayName); @@ -6571,9 +6483,7 @@ impl IPerPropertyBrowsing { pub unsafe fn GetPredefinedStrings(&self, dispid: i32, pcastringsout: *mut CALPOLESTR, pcacookiesout: *mut CADWORD) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetPredefinedStrings)(::windows_core::Interface::as_raw(self), dispid, pcastringsout, pcacookiesout).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn GetPredefinedValue(&self, dispid: i32, dwcookie: u32) -> ::windows_core::Result { + pub unsafe fn GetPredefinedValue(&self, dispid: i32, dwcookie: u32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPredefinedValue)(::windows_core::Interface::as_raw(self), dispid, dwcookie, &mut result__).from_abi(result__) } @@ -6585,10 +6495,7 @@ pub struct IPerPropertyBrowsing_Vtbl { pub GetDisplayString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, pbstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub MapPropertyToPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, pclsid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetPredefinedStrings: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, pcastringsout: *mut CALPOLESTR, pcacookiesout: *mut CADWORD) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub GetPredefinedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, dwcookie: u32, pvarout: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - GetPredefinedValue: usize, + pub GetPredefinedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, dwcookie: u32, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -7369,38 +7276,30 @@ impl IRecordInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetTypeInfo)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn GetField(&self, pvdata: *const ::core::ffi::c_void, szfieldname: P0) -> ::windows_core::Result + pub unsafe fn GetField(&self, pvdata: *const ::core::ffi::c_void, szfieldname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetField)(::windows_core::Interface::as_raw(self), pvdata, szfieldname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn GetFieldNoCopy(&self, pvdata: *const ::core::ffi::c_void, szfieldname: P0, pvarfield: *mut super::Variant::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> + pub unsafe fn GetFieldNoCopy(&self, pvdata: *const ::core::ffi::c_void, szfieldname: P0, pvarfield: *mut ::windows_core::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).GetFieldNoCopy)(::windows_core::Interface::as_raw(self), pvdata, szfieldname.into_param().abi(), pvarfield, ppvdatacarray).ok() + (::windows_core::Interface::vtable(self).GetFieldNoCopy)(::windows_core::Interface::as_raw(self), pvdata, szfieldname.into_param().abi(), ::core::mem::transmute(pvarfield), ppvdatacarray).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn PutField(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: P0, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutField(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: P0, pvarfield: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).PutField)(::windows_core::Interface::as_raw(self), wflags, pvdata, szfieldname.into_param().abi(), pvarfield).ok() + (::windows_core::Interface::vtable(self).PutField)(::windows_core::Interface::as_raw(self), wflags, pvdata, szfieldname.into_param().abi(), ::core::mem::transmute(pvarfield)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn PutFieldNoCopy(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: P0, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutFieldNoCopy(&self, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: P0, pvarfield: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).PutFieldNoCopy)(::windows_core::Interface::as_raw(self), wflags, pvdata, szfieldname.into_param().abi(), pvarfield).ok() + (::windows_core::Interface::vtable(self).PutFieldNoCopy)(::windows_core::Interface::as_raw(self), wflags, pvdata, szfieldname.into_param().abi(), ::core::mem::transmute(pvarfield)).ok() } pub unsafe fn GetFieldNames(&self, pcnames: *mut u32, rgbstrnames: *mut ::windows_core::BSTR) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetFieldNames)(::windows_core::Interface::as_raw(self), pcnames, ::core::mem::transmute(rgbstrnames)).ok() @@ -7435,22 +7334,10 @@ pub struct IRecordInfo_Vtbl { pub GetTypeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pptypeinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetTypeInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub GetField: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - GetField: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub GetFieldNoCopy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut super::Variant::VARIANT, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - GetFieldNoCopy: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub PutField: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - PutField: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub PutFieldNoCopy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - PutFieldNoCopy: usize, + pub GetField: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetFieldNoCopy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvdata: *const ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppvdatacarray: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + pub PutField: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutFieldNoCopy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wflags: u32, pvdata: *mut ::core::ffi::c_void, szfieldname: ::windows_core::PCWSTR, pvarfield: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetFieldNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcnames: *mut u32, rgbstrnames: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsMatchingType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, precordinfo: *mut ::core::ffi::c_void) -> super::super::Foundation::BOOL, pub RecordCreate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void, @@ -7585,23 +7472,18 @@ pub struct ITypeMarshal_Vtbl { ::windows_core::imp::com_interface!(IVBFormat, IVBFormat_Vtbl, 0x9849fd60_3768_101b_8d72_ae6164ffe3cf); ::windows_core::imp::interface_hierarchy!(IVBFormat, ::windows_core::IUnknown); impl IVBFormat { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn Format(&self, vdata: *mut super::Variant::VARIANT, bstrformat: P0, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::Result<()> + pub unsafe fn Format(&self, vdata: *mut ::windows_core::VARIANT, bstrformat: P0, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).Format)(::windows_core::Interface::as_raw(self), vdata, bstrformat.into_param().abi(), lpbuffer, cb, lcid, sfirstdayofweek, sfirstweekofyear, rcb).ok() + (::windows_core::Interface::vtable(self).Format)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdata), bstrformat.into_param().abi(), lpbuffer, cb, lcid, sfirstdayofweek, sfirstweekofyear, rcb).ok() } } #[repr(C)] #[doc(hidden)] pub struct IVBFormat_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub Format: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdata: *mut super::Variant::VARIANT, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] - Format: usize, + pub Format: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrformat: ::std::mem::MaybeUninit<::windows_core::BSTR>, lpbuffer: *mut ::core::ffi::c_void, cb: u16, lcid: i32, sfirstdayofweek: i16, sfirstweekofyear: u16, rcb: *mut u16) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IVBGetControl, IVBGetControl_Vtbl, 0x40a050a0_3c31_101b_a82e_08002b2b2337); ::windows_core::imp::interface_hierarchy!(IVBGetControl, ::windows_core::IUnknown); @@ -7625,19 +7507,19 @@ pub struct IVBGetControl_Vtbl { ::windows_core::imp::com_interface!(IVariantChangeType, IVariantChangeType_Vtbl, 0xa6ef9862_c720_11d0_9337_00a0c90dcaa9); ::windows_core::imp::interface_hierarchy!(IVariantChangeType, ::windows_core::IUnknown); impl IVariantChangeType { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub unsafe fn ChangeType(&self, pvardst: *mut super::Variant::VARIANT, pvarsrc: *const super::Variant::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ChangeType)(::windows_core::Interface::as_raw(self), pvardst, pvarsrc, lcid, vtnew).ok() + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] + pub unsafe fn ChangeType(&self, pvardst: *mut ::windows_core::VARIANT, pvarsrc: *const ::windows_core::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ChangeType)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvardst), ::core::mem::transmute(pvarsrc), lcid, vtnew).ok() } } #[repr(C)] #[doc(hidden)] pub struct IVariantChangeType_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] - pub ChangeType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardst: *mut super::Variant::VARIANT, pvarsrc: *const super::Variant::VARIANT, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Variant")] + pub ChangeType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvardst: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarsrc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lcid: u32, vtnew: super::Variant::VARENUM) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Variant"))] ChangeType: usize, } ::windows_core::imp::com_interface!(IViewObject, IViewObject_Vtbl, 0x0000010d_0000_0000_c000_000000000046); @@ -12376,62 +12258,59 @@ impl ::core::default::Default for PARAMDATA { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub struct PARAMDESC { pub pparamdescex: *mut PARAMDESCEX, pub wParamFlags: PARAMFLAGS, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for PARAMDESC {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for PARAMDESC { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for PARAMDESC { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("PARAMDESC").field("pparamdescex", &self.pparamdescex).field("wParamFlags", &self.wParamFlags).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for PARAMDESC { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for PARAMDESC { fn eq(&self, other: &Self) -> bool { self.pparamdescex == other.pparamdescex && self.wParamFlags == other.wParamFlags } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for PARAMDESC {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::default::Default for PARAMDESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] pub struct PARAMDESCEX { pub cBytes: u32, - pub varDefaultValue: super::Variant::VARIANT, + pub varDefaultValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for PARAMDESCEX { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for PARAMDESCEX { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("PARAMDESCEX").field("cBytes", &self.cBytes).field("varDefaultValue", &self.varDefaultValue).finish() + } +} impl ::windows_core::TypeKind for PARAMDESCEX { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for PARAMDESCEX { + fn eq(&self, other: &Self) -> bool { + self.cBytes == other.cBytes && self.varDefaultValue == other.varDefaultValue + } +} +impl ::core::cmp::Eq for PARAMDESCEX {} impl ::core::default::Default for PARAMDESCEX { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/System/Performance/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Performance/impl.rs index 772fea06c2..e7f63b26d6 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Performance/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Performance/impl.rs @@ -1,9 +1,9 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DICounterItem_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DICounterItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DICounterItem_Vtbl { pub const fn new, Impl: DICounterItem_Impl, const OFFSET: isize>() -> DICounterItem_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -12,12 +12,12 @@ impl DICounterItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DILogFileItem_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DILogFileItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DILogFileItem_Vtbl { pub const fn new, Impl: DILogFileItem_Impl, const OFFSET: isize>() -> DILogFileItem_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -26,12 +26,12 @@ impl DILogFileItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DISystemMonitor_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DISystemMonitor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DISystemMonitor_Vtbl { pub const fn new, Impl: DISystemMonitor_Impl, const OFFSET: isize>() -> DISystemMonitor_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -40,12 +40,12 @@ impl DISystemMonitor_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DISystemMonitorEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DISystemMonitorEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DISystemMonitorEvents_Vtbl { pub const fn new, Impl: DISystemMonitorEvents_Impl, const OFFSET: isize>() -> DISystemMonitorEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -54,12 +54,12 @@ impl DISystemMonitorEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DISystemMonitorInternal_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DISystemMonitorInternal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DISystemMonitorInternal_Vtbl { pub const fn new, Impl: DISystemMonitorInternal_Impl, const OFFSET: isize>() -> DISystemMonitorInternal_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -68,8 +68,8 @@ impl DISystemMonitorInternal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAlertDataCollector_Impl: Sized + IDataCollector_Impl { fn AlertThresholds(&self) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; fn SetAlertThresholds(&self, alerts: *const super::Com::SAFEARRAY) -> ::windows_core::Result<()>; @@ -88,9 +88,9 @@ pub trait IAlertDataCollector_Impl: Sized + IDataCollector_Impl { fn TriggerDataCollectorSet(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTriggerDataCollectorSet(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAlertDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAlertDataCollector_Vtbl { pub const fn new, Impl: IAlertDataCollector_Impl, const OFFSET: isize>() -> IAlertDataCollector_Vtbl { unsafe extern "system" fn AlertThresholds, Impl: IAlertDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, alerts: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT { @@ -245,8 +245,8 @@ impl IAlertDataCollector_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IApiTracingDataCollector_Impl: Sized + IDataCollector_Impl { fn LogApiNamesOnly(&self) -> ::windows_core::Result; fn SetLogApiNamesOnly(&self, logapinames: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -263,9 +263,9 @@ pub trait IApiTracingDataCollector_Impl: Sized + IDataCollector_Impl { fn ExcludeApis(&self) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; fn SetExcludeApis(&self, excludeapis: *const super::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IApiTracingDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IApiTracingDataCollector_Vtbl { pub const fn new, Impl: IApiTracingDataCollector_Impl, const OFFSET: isize>() -> IApiTracingDataCollector_Vtbl { unsafe extern "system" fn LogApiNamesOnly, Impl: IApiTracingDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, logapinames: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -402,8 +402,8 @@ impl IApiTracingDataCollector_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IConfigurationDataCollector_Impl: Sized + IDataCollector_Impl { fn FileMaxCount(&self) -> ::windows_core::Result; fn SetFileMaxCount(&self, count: u32) -> ::windows_core::Result<()>; @@ -424,9 +424,9 @@ pub trait IConfigurationDataCollector_Impl: Sized + IDataCollector_Impl { fn SystemStateFile(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSystemStateFile(&self, filename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IConfigurationDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IConfigurationDataCollector_Vtbl { pub const fn new, Impl: IConfigurationDataCollector_Impl, const OFFSET: isize>() -> IConfigurationDataCollector_Vtbl { unsafe extern "system" fn FileMaxCount, Impl: IConfigurationDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut u32) -> ::windows_core::HRESULT { @@ -732,18 +732,14 @@ impl ICounterItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ICounterItem2_Impl: Sized + ICounterItem_Impl { fn SetSelected(&self, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Selected(&self) -> ::windows_core::Result; fn SetVisible(&self, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Visible(&self) -> ::windows_core::Result; - fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result; + fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ICounterItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ICounterItem2_Vtbl { pub const fn new, Impl: ICounterItem2_Impl, const OFFSET: isize>() -> ICounterItem2_Vtbl { unsafe extern "system" fn SetSelected, Impl: ICounterItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -778,7 +774,7 @@ impl ICounterItem2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDataAt, Impl: ICounterItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDataAt, Impl: ICounterItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDataAt(::core::mem::transmute_copy(&iindex), ::core::mem::transmute_copy(&iwhich)) { @@ -802,18 +798,18 @@ impl ICounterItem2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICounters_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pathname: &::windows_core::BSTR) -> ::windows_core::Result; - fn Remove(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICounters {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICounters_Vtbl { pub const fn new, Impl: ICounters_Impl, const OFFSET: isize>() -> ICounters_Vtbl { unsafe extern "system" fn Count, Impl: ICounters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plong: *mut i32) -> ::windows_core::HRESULT { @@ -838,7 +834,7 @@ impl ICounters_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ICounters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ICounters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -860,7 +856,7 @@ impl ICounters_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: ICounters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: ICounters_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -878,8 +874,8 @@ impl ICounters_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataCollector_Impl: Sized + super::Com::IDispatch_Impl { fn DataCollectorSet(&self) -> ::windows_core::Result; fn SetDataCollectorSet(&self, group: ::core::option::Option<&IDataCollectorSet>) -> ::windows_core::Result<()>; @@ -907,9 +903,9 @@ pub trait IDataCollector_Impl: Sized + super::Com::IDispatch_Impl { fn SetXml(&self, xml: &::windows_core::BSTR) -> ::windows_core::Result; fn CreateOutputLocation(&self, latest: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataCollector_Vtbl { pub const fn new, Impl: IDataCollector_Impl, const OFFSET: isize>() -> IDataCollector_Vtbl { unsafe extern "system" fn DataCollectorSet, Impl: IDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, group: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1160,22 +1156,22 @@ impl IDataCollector_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataCollectorCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Add(&self, collector: ::core::option::Option<&IDataCollector>) -> ::windows_core::Result<()>; - fn Remove(&self, collector: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, collector: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, collectors: ::core::option::Option<&IDataCollectorCollection>) -> ::windows_core::Result<()>; fn CreateDataCollectorFromXml(&self, bstrxml: &::windows_core::BSTR, pvalidation: *mut ::core::option::Option, pcollector: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn CreateDataCollector(&self, r#type: DataCollectorType) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataCollectorCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataCollectorCollection_Vtbl { pub const fn new, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>() -> IDataCollectorCollection_Vtbl { unsafe extern "system" fn Count, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -1189,7 +1185,7 @@ impl IDataCollectorCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, collector: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, collector: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -1216,7 +1212,7 @@ impl IDataCollectorCollection_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&collector)).into() } - unsafe extern "system" fn Remove, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, collector: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IDataCollectorCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, collector: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&collector)).into() @@ -1264,8 +1260,8 @@ impl IDataCollectorCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataCollectorSet_Impl: Sized + super::Com::IDispatch_Impl { fn DataCollectors(&self) -> ::windows_core::Result; fn Duration(&self) -> ::windows_core::Result; @@ -1328,9 +1324,9 @@ pub trait IDataCollectorSet_Impl: Sized + super::Com::IDispatch_Impl { fn SetValue(&self, key: &::windows_core::BSTR, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetValue(&self, key: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataCollectorSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataCollectorSet_Vtbl { pub const fn new, Impl: IDataCollectorSet_Impl, const OFFSET: isize>() -> IDataCollectorSet_Vtbl { unsafe extern "system" fn DataCollectors, Impl: IDataCollectorSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, collectors: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1905,21 +1901,21 @@ impl IDataCollectorSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataCollectorSetCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Add(&self, set: ::core::option::Option<&IDataCollectorSet>) -> ::windows_core::Result<()>; - fn Remove(&self, set: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, set: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, sets: ::core::option::Option<&IDataCollectorSetCollection>) -> ::windows_core::Result<()>; fn GetDataCollectorSets(&self, server: &::windows_core::BSTR, filter: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataCollectorSetCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataCollectorSetCollection_Vtbl { pub const fn new, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>() -> IDataCollectorSetCollection_Vtbl { unsafe extern "system" fn Count, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -1933,7 +1929,7 @@ impl IDataCollectorSetCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, set: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, set: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -1960,7 +1956,7 @@ impl IDataCollectorSetCollection_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&set)).into() } - unsafe extern "system" fn Remove, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, set: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IDataCollectorSetCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, set: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&set)).into() @@ -1996,8 +1992,8 @@ impl IDataCollectorSetCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataManager_Impl: Sized + super::Com::IDispatch_Impl { fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, fenabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -2025,9 +2021,9 @@ pub trait IDataManager_Impl: Sized + super::Com::IDispatch_Impl { fn Run(&self, steps: DataManagerSteps, bstrfolder: &::windows_core::BSTR) -> ::windows_core::Result; fn Extract(&self, cabfilename: &::windows_core::BSTR, destinationpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataManager_Vtbl { pub const fn new, Impl: IDataManager_Impl, const OFFSET: isize>() -> IDataManager_Vtbl { unsafe extern "system" fn Enabled, Impl: IDataManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2266,8 +2262,8 @@ impl IDataManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFolderAction_Impl: Sized + super::Com::IDispatch_Impl { fn Age(&self) -> ::windows_core::Result; fn SetAge(&self, ulage: u32) -> ::windows_core::Result<()>; @@ -2278,9 +2274,9 @@ pub trait IFolderAction_Impl: Sized + super::Com::IDispatch_Impl { fn SendCabTo(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSendCabTo(&self, bstrdestination: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFolderAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFolderAction_Vtbl { pub const fn new, Impl: IFolderAction_Impl, const OFFSET: isize>() -> IFolderAction_Vtbl { unsafe extern "system" fn Age, Impl: IFolderAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pulage: *mut u32) -> ::windows_core::HRESULT { @@ -2363,21 +2359,21 @@ impl IFolderAction_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFolderActionCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Add(&self, action: ::core::option::Option<&IFolderAction>) -> ::windows_core::Result<()>; - fn Remove(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, actions: ::core::option::Option<&IFolderActionCollection>) -> ::windows_core::Result<()>; fn CreateFolderAction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFolderActionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFolderActionCollection_Vtbl { pub const fn new, Impl: IFolderActionCollection_Impl, const OFFSET: isize>() -> IFolderActionCollection_Vtbl { unsafe extern "system" fn Count, Impl: IFolderActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut u32) -> ::windows_core::HRESULT { @@ -2391,7 +2387,7 @@ impl IFolderActionCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IFolderActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, action: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IFolderActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, action: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2418,7 +2414,7 @@ impl IFolderActionCollection_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&action)).into() } - unsafe extern "system" fn Remove, Impl: IFolderActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IFolderActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -2483,18 +2479,18 @@ impl ILogFileItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILogFiles_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, pathname: &::windows_core::BSTR) -> ::windows_core::Result; - fn Remove(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILogFiles {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILogFiles_Vtbl { pub const fn new, Impl: ILogFiles_Impl, const OFFSET: isize>() -> ILogFiles_Vtbl { unsafe extern "system" fn Count, Impl: ILogFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plong: *mut i32) -> ::windows_core::HRESULT { @@ -2519,7 +2515,7 @@ impl ILogFiles_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ILogFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ILogFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2541,7 +2537,7 @@ impl ILogFiles_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: ILogFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: ILogFiles_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -2559,8 +2555,8 @@ impl ILogFiles_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPerformanceCounterDataCollector_Impl: Sized + IDataCollector_Impl { fn DataSourceName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDataSourceName(&self, dsn: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2573,9 +2569,9 @@ pub trait IPerformanceCounterDataCollector_Impl: Sized + IDataCollector_Impl { fn SegmentMaxRecords(&self) -> ::windows_core::Result; fn SetSegmentMaxRecords(&self, records: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPerformanceCounterDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPerformanceCounterDataCollector_Vtbl { pub const fn new, Impl: IPerformanceCounterDataCollector_Impl, const OFFSET: isize>() -> IPerformanceCounterDataCollector_Vtbl { unsafe extern "system" fn DataSourceName, Impl: IPerformanceCounterDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dsn: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2676,24 +2672,24 @@ impl IPerformanceCounterDataCollector_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISchedule_Impl: Sized + super::Com::IDispatch_Impl { - fn StartDate(&self) -> ::windows_core::Result; - fn SetStartDate(&self, start: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn EndDate(&self) -> ::windows_core::Result; - fn SetEndDate(&self, end: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn StartTime(&self) -> ::windows_core::Result; - fn SetStartTime(&self, start: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn StartDate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetStartDate(&self, start: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn EndDate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetEndDate(&self, end: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn StartTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetStartTime(&self, start: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Days(&self) -> ::windows_core::Result; fn SetDays(&self, days: WeekDays) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISchedule {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISchedule_Vtbl { pub const fn new, Impl: ISchedule_Impl, const OFFSET: isize>() -> ISchedule_Vtbl { - unsafe extern "system" fn StartDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StartDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StartDate() { @@ -2704,12 +2700,12 @@ impl ISchedule_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetStartDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetStartDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetStartDate(::core::mem::transmute(&start)).into() } - unsafe extern "system" fn EndDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, end: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EndDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, end: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EndDate() { @@ -2720,12 +2716,12 @@ impl ISchedule_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetEndDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, end: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetEndDate, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, end: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetEndDate(::core::mem::transmute(&end)).into() } - unsafe extern "system" fn StartTime, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn StartTime, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.StartTime() { @@ -2736,7 +2732,7 @@ impl ISchedule_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetStartTime, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetStartTime, Impl: ISchedule_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, start: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetStartTime(::core::mem::transmute(&start)).into() @@ -2773,21 +2769,21 @@ impl ISchedule_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IScheduleCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Add(&self, pschedule: ::core::option::Option<&ISchedule>) -> ::windows_core::Result<()>; - fn Remove(&self, vschedule: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, vschedule: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, pschedules: ::core::option::Option<&IScheduleCollection>) -> ::windows_core::Result<()>; fn CreateSchedule(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IScheduleCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IScheduleCollection_Vtbl { pub const fn new, Impl: IScheduleCollection_Impl, const OFFSET: isize>() -> IScheduleCollection_Vtbl { unsafe extern "system" fn Count, Impl: IScheduleCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2801,7 +2797,7 @@ impl IScheduleCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IScheduleCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppschedule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IScheduleCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppschedule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2828,7 +2824,7 @@ impl IScheduleCollection_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pschedule)).into() } - unsafe extern "system" fn Remove, Impl: IScheduleCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vschedule: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IScheduleCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vschedule: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&vschedule)).into() @@ -3882,8 +3878,8 @@ impl ISystemMonitorEvents_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITraceDataCollector_Impl: Sized + IDataCollector_Impl { fn BufferSize(&self) -> ::windows_core::Result; fn SetBufferSize(&self, size: u32) -> ::windows_core::Result<()>; @@ -3926,9 +3922,9 @@ pub trait ITraceDataCollector_Impl: Sized + IDataCollector_Impl { fn SetStreamMode(&self, mode: StreamMode) -> ::windows_core::Result<()>; fn TraceDataProviders(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITraceDataCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITraceDataCollector_Vtbl { pub const fn new, Impl: ITraceDataCollector_Impl, const OFFSET: isize>() -> ITraceDataCollector_Vtbl { unsafe extern "system" fn BufferSize, Impl: ITraceDataCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, size: *mut u32) -> ::windows_core::HRESULT { @@ -4305,8 +4301,8 @@ impl ITraceDataCollector_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITraceDataProvider_Impl: Sized + super::Com::IDispatch_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDisplayName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4328,9 +4324,9 @@ pub trait ITraceDataProvider_Impl: Sized + super::Com::IDispatch_Impl { fn GetSecurity(&self, securityinfo: u32) -> ::windows_core::Result<::windows_core::BSTR>; fn GetRegisteredProcesses(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITraceDataProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITraceDataProvider_Vtbl { pub const fn new, Impl: ITraceDataProvider_Impl, const OFFSET: isize>() -> ITraceDataProvider_Vtbl { unsafe extern "system" fn DisplayName, Impl: ITraceDataProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4521,23 +4517,23 @@ impl ITraceDataProvider_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITraceDataProviderCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Add(&self, pprovider: ::core::option::Option<&ITraceDataProvider>) -> ::windows_core::Result<()>; - fn Remove(&self, vprovider: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, vprovider: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, providers: ::core::option::Option<&ITraceDataProviderCollection>) -> ::windows_core::Result<()>; fn CreateTraceDataProvider(&self) -> ::windows_core::Result; fn GetTraceDataProviders(&self, server: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetTraceDataProvidersByProcess(&self, server: &::windows_core::BSTR, pid: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITraceDataProviderCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITraceDataProviderCollection_Vtbl { pub const fn new, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>() -> ITraceDataProviderCollection_Vtbl { unsafe extern "system" fn Count, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -4551,7 +4547,7 @@ impl ITraceDataProviderCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -4578,7 +4574,7 @@ impl ITraceDataProviderCollection_Vtbl { let this = (*this).get_impl(); this.Add(::windows_core::from_raw_borrowed(&pprovider)).into() } - unsafe extern "system" fn Remove, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vprovider: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: ITraceDataProviderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vprovider: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&vprovider)).into() @@ -4632,27 +4628,27 @@ impl ITraceDataProviderCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IValueMap_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ValueMapType(&self) -> ::windows_core::Result; fn SetValueMapType(&self, r#type: ValueMapType) -> ::windows_core::Result<()>; - fn Add(&self, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Remove(&self, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Add(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn AddRange(&self, map: ::core::option::Option<&IValueMap>) -> ::windows_core::Result<()>; fn CreateValueMapItem(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IValueMap {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IValueMap_Vtbl { pub const fn new, Impl: IValueMap_Impl, const OFFSET: isize>() -> IValueMap_Vtbl { unsafe extern "system" fn Count, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -4666,7 +4662,7 @@ impl IValueMap_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, value: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, value: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -4704,7 +4700,7 @@ impl IValueMap_Vtbl { let this = (*this).get_impl(); this.SetDescription(::core::mem::transmute(&description)).into() } - unsafe extern "system" fn Value, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -4715,7 +4711,7 @@ impl IValueMap_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&value)).into() @@ -4736,12 +4732,12 @@ impl IValueMap_Vtbl { let this = (*this).get_impl(); this.SetValueMapType(::core::mem::transmute_copy(&r#type)).into() } - unsafe extern "system" fn Add, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute(&value)).into() } - unsafe extern "system" fn Remove, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IValueMap_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&value)).into() @@ -4789,8 +4785,8 @@ impl IValueMap_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IValueMapItem_Impl: Sized + super::Com::IDispatch_Impl { fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4798,14 +4794,14 @@ pub trait IValueMapItem_Impl: Sized + super::Com::IDispatch_Impl { fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Key(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetKey(&self, key: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ValueMapType(&self) -> ::windows_core::Result; fn SetValueMapType(&self, r#type: ValueMapType) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IValueMapItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IValueMapItem_Vtbl { pub const fn new, Impl: IValueMapItem_Impl, const OFFSET: isize>() -> IValueMapItem_Vtbl { unsafe extern "system" fn Description, Impl: IValueMapItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, description: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4856,7 +4852,7 @@ impl IValueMapItem_Vtbl { let this = (*this).get_impl(); this.SetKey(::core::mem::transmute(&key)).into() } - unsafe extern "system" fn Value, Impl: IValueMapItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: IValueMapItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -4867,7 +4863,7 @@ impl IValueMapItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IValueMapItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IValueMapItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&value)).into() @@ -4906,8 +4902,6 @@ impl IValueMapItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait _ICounterItemUnion_Impl: Sized { fn Value(&self) -> ::windows_core::Result; fn SetColor(&self, color: u32) -> ::windows_core::Result<()>; @@ -4925,11 +4919,9 @@ pub trait _ICounterItemUnion_Impl: Sized { fn Selected(&self) -> ::windows_core::Result; fn SetVisible(&self, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Visible(&self) -> ::windows_core::Result; - fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result; + fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for _ICounterItemUnion {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl _ICounterItemUnion_Vtbl { pub const fn new, Impl: _ICounterItemUnion_Impl, const OFFSET: isize>() -> _ICounterItemUnion_Vtbl { unsafe extern "system" fn Value, Impl: _ICounterItemUnion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdblvalue: *mut f64) -> ::windows_core::HRESULT { @@ -5060,7 +5052,7 @@ impl _ICounterItemUnion_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDataAt, Impl: _ICounterItemUnion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDataAt, Impl: _ICounterItemUnion_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDataAt(::core::mem::transmute_copy(&iindex), ::core::mem::transmute_copy(&iwhich)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/Performance/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Performance/mod.rs index 1cb8a85c1c..379ceaee3c 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Performance/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Performance/mod.rs @@ -1973,9 +1973,7 @@ impl ICounterItem2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Visible)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result { + pub unsafe fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDataAt)(::windows_core::Interface::as_raw(self), iindex, iwhich, &mut result__).from_abi(result__) } @@ -1988,10 +1986,7 @@ pub struct ICounterItem2_Vtbl { pub Selected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstate: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetVisible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Visible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstate: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDataAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDataAt: usize, + pub GetDataAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2012,11 +2007,14 @@ impl ICounters { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2027,10 +2025,11 @@ impl ICounters { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pathname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2040,18 +2039,15 @@ pub struct ICounters_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plong: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppiunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pathname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2246,11 +2242,14 @@ impl IDataCollectorCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -2264,10 +2263,11 @@ impl IDataCollectorCollection { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), collector.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, collector: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(collector)).ok() + pub unsafe fn Remove(&self, collector: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), collector.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -2301,19 +2301,16 @@ impl IDataCollectorCollection { pub struct IDataCollectorCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, collector: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, collector: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collector: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collector: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collector: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, collectors: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2740,11 +2737,14 @@ impl IDataCollectorSetCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -2758,10 +2758,11 @@ impl IDataCollectorSetCollection { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), set.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, set: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(set)).ok() + pub unsafe fn Remove(&self, set: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), set.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -2788,19 +2789,16 @@ impl IDataCollectorSetCollection { pub struct IDataCollectorSetCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, set: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, set: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, set: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, set: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, set: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sets: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3049,11 +3047,14 @@ impl IFolderActionCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -3067,10 +3068,11 @@ impl IFolderActionCollection { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), action.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -3096,19 +3098,16 @@ impl IFolderActionCollection { pub struct IFolderActionCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, action: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, action: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#enum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, action: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, actions: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3152,11 +3151,14 @@ impl ILogFiles { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3167,10 +3169,11 @@ impl ILogFiles { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pathname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3180,18 +3183,15 @@ pub struct ILogFiles_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plong: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppiunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pathname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3406,38 +3406,35 @@ pub struct IPerformanceCounterDataCollector_Vtbl { ::windows_core::imp::interface_hierarchy!(ISchedule, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISchedule { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StartDate(&self) -> ::windows_core::Result { + pub unsafe fn StartDate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StartDate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetStartDate(&self, start: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetStartDate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(start)).ok() + pub unsafe fn SetStartDate(&self, start: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetStartDate)(::windows_core::Interface::as_raw(self), start.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EndDate(&self) -> ::windows_core::Result { + pub unsafe fn EndDate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EndDate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetEndDate(&self, end: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetEndDate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(end)).ok() + pub unsafe fn SetEndDate(&self, end: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetEndDate)(::windows_core::Interface::as_raw(self), end.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn StartTime(&self) -> ::windows_core::Result { + pub unsafe fn StartTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).StartTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetStartTime(&self, start: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetStartTime)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(start)).ok() + pub unsafe fn SetStartTime(&self, start: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetStartTime)(::windows_core::Interface::as_raw(self), start.into_param().abi()).ok() } pub unsafe fn Days(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3452,30 +3449,12 @@ impl ISchedule { #[doc(hidden)] pub struct ISchedule_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StartDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StartDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetStartDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetStartDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EndDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, end: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EndDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetEndDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, end: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetEndDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub StartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - StartTime: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetStartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetStartTime: usize, + pub StartDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetStartDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub EndDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, end: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetEndDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, end: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub StartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetStartTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, start: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Days: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, days: *mut WeekDays) -> ::windows_core::HRESULT, pub SetDays: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, days: WeekDays) -> ::windows_core::HRESULT, } @@ -3494,11 +3473,14 @@ impl IScheduleCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -3512,10 +3494,11 @@ impl IScheduleCollection { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pschedule.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, vschedule: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vschedule)).ok() + pub unsafe fn Remove(&self, vschedule: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), vschedule.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -3541,19 +3524,16 @@ impl IScheduleCollection { pub struct IScheduleCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppschedule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppschedule: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ienum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pschedule: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vschedule: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vschedule: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pschedules: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4980,11 +4960,14 @@ impl ITraceDataProviderCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -4998,10 +4981,11 @@ impl ITraceDataProviderCollection { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pprovider.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, vprovider: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vprovider)).ok() + pub unsafe fn Remove(&self, vprovider: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), vprovider.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -5039,19 +5023,16 @@ impl ITraceDataProviderCollection { pub struct ITraceDataProviderCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vprovider: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vprovider: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, providers: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5079,11 +5060,14 @@ impl IValueMap { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -5099,16 +5083,15 @@ impl IValueMap { { (::windows_core::Interface::vtable(self).SetDescription)(::windows_core::Interface::as_raw(self), description.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, value: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn ValueMapType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5117,15 +5100,17 @@ impl IValueMap { pub unsafe fn SetValueMapType(&self, r#type: ValueMapType) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetValueMapType)(::windows_core::Interface::as_raw(self), r#type).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, value: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn Add(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, value: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn Remove(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -5151,31 +5136,19 @@ impl IValueMap { pub struct IValueMap_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, value: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, value: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, description: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, description: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ValueMapType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut ValueMapType) -> ::windows_core::HRESULT, pub SetValueMapType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: ValueMapType) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, map: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5227,16 +5200,15 @@ impl IValueMapItem { { (::windows_core::Interface::vtable(self).SetKey)(::windows_core::Interface::as_raw(self), key.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, value: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() + pub unsafe fn SetValue(&self, value: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } pub unsafe fn ValueMapType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -5257,14 +5229,8 @@ pub struct IValueMapItem_Vtbl { pub SetEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Key: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ValueMapType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut ValueMapType) -> ::windows_core::HRESULT, pub SetValueMapType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: ValueMapType) -> ::windows_core::HRESULT, } @@ -5333,9 +5299,7 @@ impl _ICounterItemUnion { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Visible)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result { + pub unsafe fn GetDataAt(&self, iindex: i32, iwhich: SysmonDataType) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDataAt)(::windows_core::Interface::as_raw(self), iindex, iwhich, &mut result__).from_abi(result__) } @@ -5360,10 +5324,7 @@ pub struct _ICounterItemUnion_Vtbl { pub Selected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstate: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetVisible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Visible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstate: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDataAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDataAt: usize, + pub GetDataAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iindex: i32, iwhich: SysmonDataType, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(_ISystemMonitorUnion, _ISystemMonitorUnion_Vtbl, 0xc8a77338_265f_4de5_aa25_c7da1ce5a8f4); ::windows_core::imp::interface_hierarchy!(_ISystemMonitorUnion, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/impl.rs b/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/impl.rs index 833d844b92..99113caeed 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/impl.rs @@ -210,14 +210,14 @@ impl IRTCBuddy2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCBuddyEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Buddy(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCBuddyEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCBuddyEvent_Vtbl { pub const fn new, Impl: IRTCBuddyEvent_Impl, const OFFSET: isize>() -> IRTCBuddyEvent_Vtbl { unsafe extern "system" fn Buddy, Impl: IRTCBuddyEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppbuddy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -237,16 +237,16 @@ impl IRTCBuddyEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCBuddyEvent2_Impl: Sized + IRTCBuddyEvent_Impl { fn EventType(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCBuddyEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCBuddyEvent2_Vtbl { pub const fn new, Impl: IRTCBuddyEvent2_Impl, const OFFSET: isize>() -> IRTCBuddyEvent2_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCBuddyEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventtype: *mut RTC_BUDDY_EVENT_TYPE) -> ::windows_core::HRESULT { @@ -403,17 +403,17 @@ impl IRTCBuddyGroup_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCBuddyGroupEvent_Impl: Sized + super::Com::IDispatch_Impl { fn EventType(&self) -> ::windows_core::Result; fn Group(&self) -> ::windows_core::Result; fn Buddy(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCBuddyGroupEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCBuddyGroupEvent_Vtbl { pub const fn new, Impl: IRTCBuddyGroupEvent_Impl, const OFFSET: isize>() -> IRTCBuddyGroupEvent_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCBuddyGroupEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventtype: *mut RTC_GROUP_EVENT_TYPE) -> ::windows_core::HRESULT { @@ -472,8 +472,8 @@ impl IRTCBuddyGroupEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_DirectShow\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_DirectShow\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] pub trait IRTCClient_Impl: Sized { fn Initialize(&self) -> ::windows_core::Result<()>; fn Shutdown(&self) -> ::windows_core::Result<()>; @@ -486,7 +486,7 @@ pub trait IRTCClient_Impl: Sized { fn CreateSession(&self, entype: RTC_SESSION_TYPE, bstrlocalphoneuri: &::windows_core::BSTR, pprofile: ::core::option::Option<&IRTCProfile>, lflags: i32) -> ::windows_core::Result; fn SetListenForIncomingSessions(&self, enlisten: RTC_LISTEN_MODE) -> ::windows_core::Result<()>; fn ListenForIncomingSessions(&self) -> ::windows_core::Result; - fn get_NetworkAddresses(&self, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; + fn get_NetworkAddresses(&self, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; fn put_Volume(&self, endevice: RTC_AUDIO_DEVICE, lvolume: i32) -> ::windows_core::Result<()>; fn get_Volume(&self, endevice: RTC_AUDIO_DEVICE) -> ::windows_core::Result; fn put_AudioMuted(&self, endevice: RTC_AUDIO_DEVICE, fmuted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -518,9 +518,9 @@ pub trait IRTCClient_Impl: Sized { fn InvokeTuningWizard(&self, hwndparent: isize) -> ::windows_core::Result<()>; fn IsTuned(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IRTCClient {} -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] impl IRTCClient_Vtbl { pub const fn new, Impl: IRTCClient_Impl, const OFFSET: isize>() -> IRTCClient_Vtbl { unsafe extern "system" fn Initialize, Impl: IRTCClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -608,7 +608,7 @@ impl IRTCClient_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_NetworkAddresses, Impl: IRTCClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL, pvaddresses: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_NetworkAddresses, Impl: IRTCClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL, pvaddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_NetworkAddresses(::core::mem::transmute_copy(&ftcp), ::core::mem::transmute_copy(&fexternal)) { @@ -909,8 +909,8 @@ impl IRTCClient_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Media_DirectShow\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Media_DirectShow\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] pub trait IRTCClient2_Impl: Sized + IRTCClient_Impl { fn put_AnswerMode(&self, entype: RTC_SESSION_TYPE, enmode: RTC_ANSWER_MODE) -> ::windows_core::Result<()>; fn get_AnswerMode(&self, entype: RTC_SESSION_TYPE) -> ::windows_core::Result; @@ -926,9 +926,9 @@ pub trait IRTCClient2_Impl: Sized + IRTCClient_Impl { fn put_AllowedPorts(&self, ltransport: i32, enlistenmode: RTC_LISTEN_MODE) -> ::windows_core::Result<()>; fn get_AllowedPorts(&self, ltransport: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IRTCClient2 {} -#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Media_DirectShow", feature = "Win32_System_Com"))] impl IRTCClient2_Vtbl { pub const fn new, Impl: IRTCClient2_Impl, const OFFSET: isize>() -> IRTCClient2_Vtbl { unsafe extern "system" fn put_AnswerMode, Impl: IRTCClient2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, entype: RTC_SESSION_TYPE, enmode: RTC_ANSWER_MODE) -> ::windows_core::HRESULT { @@ -1047,15 +1047,15 @@ impl IRTCClient2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCClientEvent_Impl: Sized + super::Com::IDispatch_Impl { fn EventType(&self) -> ::windows_core::Result; fn Client(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCClientEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCClientEvent_Vtbl { pub const fn new, Impl: IRTCClientEvent_Impl, const OFFSET: isize>() -> IRTCClientEvent_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCClientEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peneventtype: *mut RTC_CLIENT_EVENT_TYPE) -> ::windows_core::HRESULT { @@ -1124,12 +1124,12 @@ impl IRTCClientPortManagement_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCClientPresence_Impl: Sized { - fn EnablePresence(&self, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Export(&self, varstorage: &super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Import(&self, varstorage: &super::Variant::VARIANT, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; + fn EnablePresence(&self, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Export(&self, varstorage: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Import(&self, varstorage: &::windows_core::VARIANT, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn EnumerateBuddies(&self) -> ::windows_core::Result; fn Buddies(&self) -> ::windows_core::Result; fn get_Buddy(&self, bstrpresentityuri: &::windows_core::BSTR) -> ::windows_core::Result; @@ -1146,22 +1146,22 @@ pub trait IRTCClientPresence_Impl: Sized { fn PrivacyMode(&self) -> ::windows_core::Result; fn SetPrivacyMode(&self, enmode: RTC_PRIVACY_MODE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCClientPresence {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCClientPresence_Vtbl { pub const fn new, Impl: IRTCClientPresence_Impl, const OFFSET: isize>() -> IRTCClientPresence_Vtbl { - unsafe extern "system" fn EnablePresence, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnablePresence, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnablePresence(::core::mem::transmute_copy(&fusestorage), ::core::mem::transmute(&varstorage)).into() } - unsafe extern "system" fn Export, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Export, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Export(::core::mem::transmute(&varstorage)).into() } - unsafe extern "system" fn Import, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn Import, Impl: IRTCClientPresence_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Import(::core::mem::transmute(&varstorage), ::core::mem::transmute_copy(&freplaceall)).into() @@ -1327,10 +1327,10 @@ impl IRTCClientPresence_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCClientPresence2_Impl: Sized + IRTCClientPresence_Impl { - fn EnablePresenceEx(&self, pprofile: ::core::option::Option<&IRTCProfile>, varstorage: &super::Variant::VARIANT, lflags: i32) -> ::windows_core::Result<()>; + fn EnablePresenceEx(&self, pprofile: ::core::option::Option<&IRTCProfile>, varstorage: &::windows_core::VARIANT, lflags: i32) -> ::windows_core::Result<()>; fn DisablePresence(&self) -> ::windows_core::Result<()>; fn AddGroup(&self, bstrgroupname: &::windows_core::BSTR, bstrdata: &::windows_core::BSTR, pprofile: ::core::option::Option<&IRTCProfile>, lflags: i32) -> ::windows_core::Result; fn RemoveGroup(&self, pgroup: ::core::option::Option<&IRTCBuddyGroup>) -> ::windows_core::Result<()>; @@ -1346,12 +1346,12 @@ pub trait IRTCClientPresence2_Impl: Sized + IRTCClientPresence_Impl { fn GetLocalPresenceInfo(&self, penstatus: *mut RTC_PRESENCE_STATUS, pbstrnotes: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddBuddyEx(&self, bstrpresentityuri: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR, bstrdata: &::windows_core::BSTR, fpersistent: super::super::Foundation::VARIANT_BOOL, ensubscriptiontype: RTC_BUDDY_SUBSCRIPTION_TYPE, pprofile: ::core::option::Option<&IRTCProfile>, lflags: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCClientPresence2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCClientPresence2_Vtbl { pub const fn new, Impl: IRTCClientPresence2_Impl, const OFFSET: isize>() -> IRTCClientPresence2_Vtbl { - unsafe extern "system" fn EnablePresenceEx, Impl: IRTCClientPresence2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprofile: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT, lflags: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnablePresenceEx, Impl: IRTCClientPresence2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprofile: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lflags: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.EnablePresenceEx(::windows_core::from_raw_borrowed(&pprofile), ::core::mem::transmute(&varstorage), ::core::mem::transmute_copy(&lflags)).into() @@ -1608,16 +1608,16 @@ impl IRTCClientProvisioning2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: i32) -> ::windows_core::Result; + fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCCollection_Vtbl { pub const fn new, Impl: IRTCCollection_Impl, const OFFSET: isize>() -> IRTCCollection_Vtbl { unsafe extern "system" fn Count, Impl: IRTCCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT { @@ -1631,7 +1631,7 @@ impl IRTCCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IRTCCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IRTCCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute_copy(&index)) { @@ -1664,12 +1664,12 @@ impl IRTCCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCDispatchEventNotification_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCDispatchEventNotification {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCDispatchEventNotification_Vtbl { pub const fn new, Impl: IRTCDispatchEventNotification_Impl, const OFFSET: isize>() -> IRTCDispatchEventNotification_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -2028,17 +2028,17 @@ impl IRTCEventNotification_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCInfoEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Participant(&self) -> ::windows_core::Result; fn Info(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InfoHeader(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCInfoEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCInfoEvent_Vtbl { pub const fn new, Impl: IRTCInfoEvent_Impl, const OFFSET: isize>() -> IRTCInfoEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCInfoEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2097,17 +2097,17 @@ impl IRTCInfoEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCIntensityEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Level(&self) -> ::windows_core::Result; fn Min(&self) -> ::windows_core::Result; fn Max(&self) -> ::windows_core::Result; fn Direction(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCIntensityEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCIntensityEvent_Vtbl { pub const fn new, Impl: IRTCIntensityEvent_Impl, const OFFSET: isize>() -> IRTCIntensityEvent_Vtbl { unsafe extern "system" fn Level, Impl: IRTCIntensityEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pllevel: *mut i32) -> ::windows_core::HRESULT { @@ -2166,16 +2166,16 @@ impl IRTCIntensityEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCMediaEvent_Impl: Sized + super::Com::IDispatch_Impl { fn MediaType(&self) -> ::windows_core::Result; fn EventType(&self) -> ::windows_core::Result; fn EventReason(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCMediaEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCMediaEvent_Vtbl { pub const fn new, Impl: IRTCMediaEvent_Impl, const OFFSET: isize>() -> IRTCMediaEvent_Vtbl { unsafe extern "system" fn MediaType, Impl: IRTCMediaEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pmediatype: *mut i32) -> ::windows_core::HRESULT { @@ -2222,8 +2222,8 @@ impl IRTCMediaEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCMediaRequestEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn ProposedMedia(&self) -> ::windows_core::Result; @@ -2233,9 +2233,9 @@ pub trait IRTCMediaRequestEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Reject(&self) -> ::windows_core::Result<()>; fn State(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCMediaRequestEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCMediaRequestEvent_Vtbl { pub const fn new, Impl: IRTCMediaRequestEvent_Impl, const OFFSET: isize>() -> IRTCMediaRequestEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCMediaRequestEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2318,8 +2318,8 @@ impl IRTCMediaRequestEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCMessagingEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Participant(&self) -> ::windows_core::Result; @@ -2328,9 +2328,9 @@ pub trait IRTCMessagingEvent_Impl: Sized + super::Com::IDispatch_Impl { fn MessageHeader(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn UserStatus(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCMessagingEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCMessagingEvent_Vtbl { pub const fn new, Impl: IRTCMessagingEvent_Impl, const OFFSET: isize>() -> IRTCMessagingEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCMessagingEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2491,16 +2491,16 @@ impl IRTCParticipant_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCParticipantStateChangeEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Participant(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCParticipantStateChangeEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCParticipantStateChangeEvent_Vtbl { pub const fn new, Impl: IRTCParticipantStateChangeEvent_Impl, const OFFSET: isize>() -> IRTCParticipantStateChangeEvent_Vtbl { unsafe extern "system" fn Participant, Impl: IRTCParticipantStateChangeEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppparticipant: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2674,16 +2674,16 @@ impl IRTCPresenceContact_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCPresenceDataEvent_Impl: Sized + super::Com::IDispatch_Impl { fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetPresenceData(&self, pbstrnamespace: *mut ::windows_core::BSTR, pbstrdata: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCPresenceDataEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCPresenceDataEvent_Vtbl { pub const fn new, Impl: IRTCPresenceDataEvent_Impl, const OFFSET: isize>() -> IRTCPresenceDataEvent_Vtbl { unsafe extern "system" fn StatusCode, Impl: IRTCPresenceDataEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plstatuscode: *mut i32) -> ::windows_core::HRESULT { @@ -2783,17 +2783,17 @@ impl IRTCPresenceDevice_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCPresencePropertyEvent_Impl: Sized + super::Com::IDispatch_Impl { fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn PresenceProperty(&self) -> ::windows_core::Result; fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCPresencePropertyEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCPresencePropertyEvent_Vtbl { pub const fn new, Impl: IRTCPresencePropertyEvent_Impl, const OFFSET: isize>() -> IRTCPresencePropertyEvent_Vtbl { unsafe extern "system" fn StatusCode, Impl: IRTCPresencePropertyEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plstatuscode: *mut i32) -> ::windows_core::HRESULT { @@ -2852,16 +2852,16 @@ impl IRTCPresencePropertyEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCPresenceStatusEvent_Impl: Sized + super::Com::IDispatch_Impl { fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetLocalPresenceInfo(&self, penstatus: *mut RTC_PRESENCE_STATUS, pbstrnotes: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCPresenceStatusEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCPresenceStatusEvent_Vtbl { pub const fn new, Impl: IRTCPresenceStatusEvent_Impl, const OFFSET: isize>() -> IRTCPresenceStatusEvent_Vtbl { unsafe extern "system" fn StatusCode, Impl: IRTCPresenceStatusEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plstatuscode: *mut i32) -> ::windows_core::HRESULT { @@ -3196,16 +3196,16 @@ impl IRTCProfile2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCProfileEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Profile(&self) -> ::windows_core::Result; fn Cookie(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCProfileEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCProfileEvent_Vtbl { pub const fn new, Impl: IRTCProfileEvent_Impl, const OFFSET: isize>() -> IRTCProfileEvent_Vtbl { unsafe extern "system" fn Profile, Impl: IRTCProfileEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppprofile: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3252,14 +3252,14 @@ impl IRTCProfileEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCProfileEvent2_Impl: Sized + IRTCProfileEvent_Impl { fn EventType(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCProfileEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCProfileEvent2_Vtbl { pub const fn new, Impl: IRTCProfileEvent2_Impl, const OFFSET: isize>() -> IRTCProfileEvent2_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCProfileEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventtype: *mut RTC_PROFILE_EVENT_TYPE) -> ::windows_core::HRESULT { @@ -3279,8 +3279,8 @@ impl IRTCProfileEvent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCReInviteEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Accept(&self, bstrcontenttype: &::windows_core::BSTR, bstrsessiondescription: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3288,9 +3288,9 @@ pub trait IRTCReInviteEvent_Impl: Sized + super::Com::IDispatch_Impl { fn State(&self) -> ::windows_core::Result; fn GetRemoteSessionDescription(&self, pbstrcontenttype: *mut ::windows_core::BSTR, pbstrsessiondescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCReInviteEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCReInviteEvent_Vtbl { pub const fn new, Impl: IRTCReInviteEvent_Impl, const OFFSET: isize>() -> IRTCReInviteEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCReInviteEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession2: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3343,17 +3343,17 @@ impl IRTCReInviteEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCRegistrationStateChangeEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Profile(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCRegistrationStateChangeEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCRegistrationStateChangeEvent_Vtbl { pub const fn new, Impl: IRTCRegistrationStateChangeEvent_Impl, const OFFSET: isize>() -> IRTCRegistrationStateChangeEvent_Vtbl { unsafe extern "system" fn Profile, Impl: IRTCRegistrationStateChangeEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppprofile: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3412,17 +3412,17 @@ impl IRTCRegistrationStateChangeEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCRoamingEvent_Impl: Sized + super::Com::IDispatch_Impl { fn EventType(&self) -> ::windows_core::Result; fn Profile(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCRoamingEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCRoamingEvent_Vtbl { pub const fn new, Impl: IRTCRoamingEvent_Impl, const OFFSET: isize>() -> IRTCRoamingEvent_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCRoamingEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventtype: *mut RTC_ROAMING_EVENT_TYPE) -> ::windows_core::HRESULT { @@ -3883,17 +3883,17 @@ impl IRTCSessionDescriptionManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionOperationCompleteEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn Cookie(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionOperationCompleteEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionOperationCompleteEvent_Vtbl { pub const fn new, Impl: IRTCSessionOperationCompleteEvent_Impl, const OFFSET: isize>() -> IRTCSessionOperationCompleteEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCSessionOperationCompleteEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3952,15 +3952,15 @@ impl IRTCSessionOperationCompleteEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionOperationCompleteEvent2_Impl: Sized + IRTCSessionOperationCompleteEvent_Impl { fn Participant(&self) -> ::windows_core::Result; fn GetRemoteSessionDescription(&self, pbstrcontenttype: *mut ::windows_core::BSTR, pbstrsessiondescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionOperationCompleteEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionOperationCompleteEvent2_Vtbl { pub const fn new, Impl: IRTCSessionOperationCompleteEvent2_Impl, const OFFSET: isize>() -> IRTCSessionOperationCompleteEvent2_Vtbl { unsafe extern "system" fn Participant, Impl: IRTCSessionOperationCompleteEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppparticipant: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4006,17 +4006,17 @@ impl IRTCSessionPortManagement_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionReferStatusEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn ReferStatus(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionReferStatusEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionReferStatusEvent_Vtbl { pub const fn new, Impl: IRTCSessionReferStatusEvent_Impl, const OFFSET: isize>() -> IRTCSessionReferStatusEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCSessionReferStatusEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4075,8 +4075,8 @@ impl IRTCSessionReferStatusEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionReferredEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn ReferredByURI(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4086,9 +4086,9 @@ pub trait IRTCSessionReferredEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Reject(&self) -> ::windows_core::Result<()>; fn SetReferredSessionState(&self, enstate: RTC_SESSION_STATE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionReferredEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionReferredEvent_Vtbl { pub const fn new, Impl: IRTCSessionReferredEvent_Impl, const OFFSET: isize>() -> IRTCSessionReferredEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCSessionReferredEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4165,17 +4165,17 @@ impl IRTCSessionReferredEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionStateChangeEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Session(&self) -> ::windows_core::Result; fn State(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; fn StatusText(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionStateChangeEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionStateChangeEvent_Vtbl { pub const fn new, Impl: IRTCSessionStateChangeEvent_Impl, const OFFSET: isize>() -> IRTCSessionStateChangeEvent_Vtbl { unsafe extern "system" fn Session, Impl: IRTCSessionStateChangeEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4234,17 +4234,17 @@ impl IRTCSessionStateChangeEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCSessionStateChangeEvent2_Impl: Sized + IRTCSessionStateChangeEvent_Impl { fn MediaTypes(&self) -> ::windows_core::Result; fn get_RemotePreferredSecurityLevel(&self, ensecuritytype: RTC_SECURITY_TYPE) -> ::windows_core::Result; fn IsForked(&self) -> ::windows_core::Result; fn GetRemoteSessionDescription(&self, pbstrcontenttype: *mut ::windows_core::BSTR, pbstrsessiondescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCSessionStateChangeEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCSessionStateChangeEvent2_Vtbl { pub const fn new, Impl: IRTCSessionStateChangeEvent2_Impl, const OFFSET: isize>() -> IRTCSessionStateChangeEvent2_Vtbl { unsafe extern "system" fn MediaTypes, Impl: IRTCSessionStateChangeEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pmediatypes: *mut i32) -> ::windows_core::HRESULT { @@ -4439,8 +4439,8 @@ impl IRTCUserSearchResult_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCUserSearchResultsEvent_Impl: Sized + super::Com::IDispatch_Impl { fn EnumerateResults(&self) -> ::windows_core::Result; fn Results(&self) -> ::windows_core::Result; @@ -4450,9 +4450,9 @@ pub trait IRTCUserSearchResultsEvent_Impl: Sized + super::Com::IDispatch_Impl { fn StatusCode(&self) -> ::windows_core::Result; fn MoreAvailable(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCUserSearchResultsEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCUserSearchResultsEvent_Vtbl { pub const fn new, Impl: IRTCUserSearchResultsEvent_Impl, const OFFSET: isize>() -> IRTCUserSearchResultsEvent_Vtbl { unsafe extern "system" fn EnumerateResults, Impl: IRTCUserSearchResultsEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4615,14 +4615,14 @@ impl IRTCWatcher2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCWatcherEvent_Impl: Sized + super::Com::IDispatch_Impl { fn Watcher(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCWatcherEvent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCWatcherEvent_Vtbl { pub const fn new, Impl: IRTCWatcherEvent_Impl, const OFFSET: isize>() -> IRTCWatcherEvent_Vtbl { unsafe extern "system" fn Watcher, Impl: IRTCWatcherEvent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppwatcher: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4642,15 +4642,15 @@ impl IRTCWatcherEvent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRTCWatcherEvent2_Impl: Sized + IRTCWatcherEvent_Impl { fn EventType(&self) -> ::windows_core::Result; fn StatusCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRTCWatcherEvent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRTCWatcherEvent2_Vtbl { pub const fn new, Impl: IRTCWatcherEvent2_Impl, const OFFSET: isize>() -> IRTCWatcherEvent2_Vtbl { unsafe extern "system" fn EventType, Impl: IRTCWatcherEvent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, peventtype: *mut RTC_WATCHER_EVENT_TYPE) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/mod.rs b/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/mod.rs index 716624bb71..98aca65127 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RealTimeCommunications/mod.rs @@ -420,9 +420,7 @@ impl IRTCClient { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ListenForIncomingSessions)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_NetworkAddresses(&self, ftcp: P0, fexternal: P1) -> ::windows_core::Result + pub unsafe fn get_NetworkAddresses(&self, ftcp: P0, fexternal: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, @@ -574,10 +572,7 @@ pub struct IRTCClient_Vtbl { pub CreateSession: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, entype: RTC_SESSION_TYPE, bstrlocalphoneuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprofile: *mut ::core::ffi::c_void, lflags: i32, ppsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetListenForIncomingSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enlisten: RTC_LISTEN_MODE) -> ::windows_core::HRESULT, pub ListenForIncomingSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penlisten: *mut RTC_LISTEN_MODE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_NetworkAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL, pvaddresses: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_NetworkAddresses: usize, + pub get_NetworkAddresses: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ftcp: super::super::Foundation::VARIANT_BOOL, fexternal: super::super::Foundation::VARIANT_BOOL, pvaddresses: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub put_Volume: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, endevice: RTC_AUDIO_DEVICE, lvolume: i32) -> ::windows_core::HRESULT, pub get_Volume: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, endevice: RTC_AUDIO_DEVICE, plvolume: *mut i32) -> ::windows_core::HRESULT, pub put_AudioMuted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, endevice: RTC_AUDIO_DEVICE, fmuted: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -660,9 +655,7 @@ impl IRTCClient2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ListenForIncomingSessions)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_NetworkAddresses(&self, ftcp: P0, fexternal: P1) -> ::windows_core::Result + pub unsafe fn get_NetworkAddresses(&self, ftcp: P0, fexternal: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, @@ -937,26 +930,25 @@ pub struct IRTCClientPortManagement_Vtbl { ::windows_core::imp::com_interface!(IRTCClientPresence, IRTCClientPresence_Vtbl, 0x11c3cbcc_0744_42d1_968a_51aa1bb274c6); ::windows_core::imp::interface_hierarchy!(IRTCClientPresence, ::windows_core::IUnknown); impl IRTCClientPresence { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnablePresence(&self, fusestorage: P0, varstorage: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn EnablePresence(&self, fusestorage: P0, varstorage: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).EnablePresence)(::windows_core::Interface::as_raw(self), fusestorage.into_param().abi(), ::core::mem::transmute(varstorage)).ok() + (::windows_core::Interface::vtable(self).EnablePresence)(::windows_core::Interface::as_raw(self), fusestorage.into_param().abi(), varstorage.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Export(&self, varstorage: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Export)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstorage)).ok() + pub unsafe fn Export(&self, varstorage: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Export)(::windows_core::Interface::as_raw(self), varstorage.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Import(&self, varstorage: super::Variant::VARIANT, freplaceall: P0) -> ::windows_core::Result<()> + pub unsafe fn Import(&self, varstorage: P0, freplaceall: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).Import)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstorage), freplaceall.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).Import)(::windows_core::Interface::as_raw(self), varstorage.into_param().abi(), freplaceall.into_param().abi()).ok() } pub unsafe fn EnumerateBuddies(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1051,18 +1043,9 @@ impl IRTCClientPresence { #[doc(hidden)] pub struct IRTCClientPresence_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnablePresence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnablePresence: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Export: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Export: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Import: usize, + pub EnablePresence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fusestorage: super::super::Foundation::VARIANT_BOOL, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Export: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Import: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>, freplaceall: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub EnumerateBuddies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Buddies: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1088,26 +1071,25 @@ pub struct IRTCClientPresence_Vtbl { ::windows_core::imp::com_interface!(IRTCClientPresence2, IRTCClientPresence2_Vtbl, 0xad1809e8_62f7_4783_909a_29c9d2cb1d34); ::windows_core::imp::interface_hierarchy!(IRTCClientPresence2, ::windows_core::IUnknown, IRTCClientPresence); impl IRTCClientPresence2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnablePresence(&self, fusestorage: P0, varstorage: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn EnablePresence(&self, fusestorage: P0, varstorage: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.EnablePresence)(::windows_core::Interface::as_raw(self), fusestorage.into_param().abi(), ::core::mem::transmute(varstorage)).ok() + (::windows_core::Interface::vtable(self).base__.EnablePresence)(::windows_core::Interface::as_raw(self), fusestorage.into_param().abi(), varstorage.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Export(&self, varstorage: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Export)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstorage)).ok() + pub unsafe fn Export(&self, varstorage: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Export)(::windows_core::Interface::as_raw(self), varstorage.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Import(&self, varstorage: super::Variant::VARIANT, freplaceall: P0) -> ::windows_core::Result<()> + pub unsafe fn Import(&self, varstorage: P0, freplaceall: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Import)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varstorage), freplaceall.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.Import)(::windows_core::Interface::as_raw(self), varstorage.into_param().abi(), freplaceall.into_param().abi()).ok() } pub unsafe fn EnumerateBuddies(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1197,13 +1179,12 @@ impl IRTCClientPresence2 { pub unsafe fn SetPrivacyMode(&self, enmode: RTC_PRIVACY_MODE) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetPrivacyMode)(::windows_core::Interface::as_raw(self), enmode).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnablePresenceEx(&self, pprofile: P0, varstorage: super::Variant::VARIANT, lflags: i32) -> ::windows_core::Result<()> + pub unsafe fn EnablePresenceEx(&self, pprofile: P0, varstorage: P1, lflags: i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).EnablePresenceEx)(::windows_core::Interface::as_raw(self), pprofile.into_param().abi(), ::core::mem::transmute(varstorage), lflags).ok() + (::windows_core::Interface::vtable(self).EnablePresenceEx)(::windows_core::Interface::as_raw(self), pprofile.into_param().abi(), varstorage.into_param().abi(), lflags).ok() } pub unsafe fn DisablePresence(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DisablePresence)(::windows_core::Interface::as_raw(self)).ok() @@ -1297,10 +1278,7 @@ impl IRTCClientPresence2 { #[doc(hidden)] pub struct IRTCClientPresence2_Vtbl { pub base__: IRTCClientPresence_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnablePresenceEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprofile: *mut ::core::ffi::c_void, varstorage: super::Variant::VARIANT, lflags: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnablePresenceEx: usize, + pub EnablePresenceEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprofile: *mut ::core::ffi::c_void, varstorage: ::std::mem::MaybeUninit<::windows_core::VARIANT>, lflags: i32) -> ::windows_core::HRESULT, pub DisablePresence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub AddGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrgroupname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrdata: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprofile: *mut ::core::ffi::c_void, lflags: i32, ppgroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RemoveGroup: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pgroup: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1453,9 +1431,7 @@ impl IRTCCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result { + pub unsafe fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index, &mut result__).from_abi(result__) } @@ -1470,10 +1446,7 @@ impl IRTCCollection { pub struct IRTCCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Item: usize, + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, pvariant: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppnewenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] diff --git a/crates/libs/windows/src/Windows/Win32/System/RemoteAssistance/impl.rs b/crates/libs/windows/src/Windows/Win32/System/RemoteAssistance/impl.rs index c6533c1f84..f554c664ae 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RemoteAssistance/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RemoteAssistance/impl.rs @@ -1,9 +1,9 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DRendezvousSessionEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DRendezvousSessionEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DRendezvousSessionEvents_Vtbl { pub const fn new, Impl: DRendezvousSessionEvents_Impl, const OFFSET: isize>() -> DRendezvousSessionEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/impl.rs b/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/impl.rs index a5279ae1a2..aa0101035f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IADsTSUserEx_Impl: Sized + super::Com::IDispatch_Impl { fn TerminalServicesProfilePath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTerminalServicesProfilePath(&self, pnewval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -32,9 +32,9 @@ pub trait IADsTSUserEx_Impl: Sized + super::Com::IDispatch_Impl { fn TerminalServicesInitialProgram(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTerminalServicesInitialProgram(&self, pnewval: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IADsTSUserEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IADsTSUserEx_Vtbl { pub const fn new, Impl: IADsTSUserEx_Impl, const OFFSET: isize>() -> IADsTSUserEx_Vtbl { unsafe extern "system" fn TerminalServicesProfilePath, Impl: IADsTSUserEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -589,8 +589,8 @@ impl IAudioOutputEndpointRT_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRemoteDesktopClient_Impl: Sized + super::Com::IDispatch_Impl { fn Connect(&self) -> ::windows_core::Result<()>; fn Disconnect(&self) -> ::windows_core::Result<()>; @@ -603,9 +603,9 @@ pub trait IRemoteDesktopClient_Impl: Sized + super::Com::IDispatch_Impl { fn attachEvent(&self, eventname: &::windows_core::BSTR, callback: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn detachEvent(&self, eventname: &::windows_core::BSTR, callback: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRemoteDesktopClient {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRemoteDesktopClient_Vtbl { pub const fn new, Impl: IRemoteDesktopClient_Impl, const OFFSET: isize>() -> IRemoteDesktopClient_Vtbl { unsafe extern "system" fn Connect, Impl: IRemoteDesktopClient_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -694,17 +694,17 @@ impl IRemoteDesktopClient_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRemoteDesktopClientActions_Impl: Sized + super::Com::IDispatch_Impl { fn SuspendScreenUpdates(&self) -> ::windows_core::Result<()>; fn ResumeScreenUpdates(&self) -> ::windows_core::Result<()>; fn ExecuteRemoteAction(&self, remoteaction: RemoteActionType) -> ::windows_core::Result<()>; fn GetSnapshot(&self, snapshotencoding: SnapshotEncodingType, snapshotformat: SnapshotFormatType, snapshotwidth: u32, snapshotheight: u32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRemoteDesktopClientActions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRemoteDesktopClientActions_Vtbl { pub const fn new, Impl: IRemoteDesktopClientActions_Impl, const OFFSET: isize>() -> IRemoteDesktopClientActions_Vtbl { unsafe extern "system" fn SuspendScreenUpdates, Impl: IRemoteDesktopClientActions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -745,17 +745,17 @@ impl IRemoteDesktopClientActions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRemoteDesktopClientSettings_Impl: Sized + super::Com::IDispatch_Impl { fn ApplySettings(&self, rdpfilecontents: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RetrieveSettings(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetRdpProperty(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result; - fn SetRdpProperty(&self, propertyname: &::windows_core::BSTR, value: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetRdpProperty(&self, propertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetRdpProperty(&self, propertyname: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRemoteDesktopClientSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRemoteDesktopClientSettings_Vtbl { pub const fn new, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>() -> IRemoteDesktopClientSettings_Vtbl { unsafe extern "system" fn ApplySettings, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rdpfilecontents: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -774,7 +774,7 @@ impl IRemoteDesktopClientSettings_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRdpProperty, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRdpProperty, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRdpProperty(::core::mem::transmute(&propertyname)) { @@ -785,7 +785,7 @@ impl IRemoteDesktopClientSettings_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetRdpProperty, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetRdpProperty, Impl: IRemoteDesktopClientSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetRdpProperty(::core::mem::transmute(&propertyname), ::core::mem::transmute(&value)).into() @@ -802,8 +802,8 @@ impl IRemoteDesktopClientSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRemoteDesktopClientTouchPointer_Impl: Sized + super::Com::IDispatch_Impl { fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Enabled(&self) -> ::windows_core::Result; @@ -812,9 +812,9 @@ pub trait IRemoteDesktopClientTouchPointer_Impl: Sized + super::Com::IDispatch_I fn SetPointerSpeed(&self, pointerspeed: u32) -> ::windows_core::Result<()>; fn PointerSpeed(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRemoteDesktopClientTouchPointer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRemoteDesktopClientTouchPointer_Vtbl { pub const fn new, Impl: IRemoteDesktopClientTouchPointer_Impl, const OFFSET: isize>() -> IRemoteDesktopClientTouchPointer_Vtbl { unsafe extern "system" fn SetEnabled, Impl: IRemoteDesktopClientTouchPointer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1104,16 +1104,16 @@ impl ITsSbBaseNotifySink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbClientConnection_Impl: Sized { fn UserName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Domain(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InitialProgram(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn LoadBalanceResult(&self) -> ::windows_core::Result; fn FarmName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn PutContext(&self, contextid: &::windows_core::BSTR, context: &super::Variant::VARIANT, existingcontext: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetContext(&self, contextid: &::windows_core::BSTR) -> ::windows_core::Result; + fn PutContext(&self, contextid: &::windows_core::BSTR, context: &::windows_core::VARIANT, existingcontext: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetContext(&self, contextid: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn Environment(&self) -> ::windows_core::Result; fn get_ConnectionError(&self) -> ::windows_core::Result<()>; fn SamUserAccount(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1123,9 +1123,9 @@ pub trait ITsSbClientConnection_Impl: Sized { fn UserSidString(&self) -> ::windows_core::Result<*mut i8>; fn GetDisconnectedSession(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbClientConnection {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbClientConnection_Vtbl { pub const fn new, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>() -> ITsSbClientConnection_Vtbl { unsafe extern "system" fn UserName, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1183,12 +1183,12 @@ impl ITsSbClientConnection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutContext, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: super::Variant::VARIANT, existingcontext: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutContext, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: ::std::mem::MaybeUninit<::windows_core::VARIANT>, existingcontext: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutContext(::core::mem::transmute(&contextid), ::core::mem::transmute(&context), ::core::mem::transmute_copy(&existingcontext)).into() } - unsafe extern "system" fn GetContext, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetContext, Impl: ITsSbClientConnection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetContext(::core::mem::transmute(&contextid)) { @@ -1304,12 +1304,12 @@ impl ITsSbClientConnection_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbClientConnectionPropertySet_Impl: Sized + ITsSbPropertySet_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbClientConnectionPropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbClientConnectionPropertySet_Vtbl { pub const fn new, Impl: ITsSbClientConnectionPropertySet_Impl, const OFFSET: isize>() -> ITsSbClientConnectionPropertySet_Vtbl { Self { base__: ITsSbPropertySet_Vtbl::new::() } @@ -1381,12 +1381,12 @@ impl ITsSbEnvironment_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbEnvironmentPropertySet_Impl: Sized + ITsSbPropertySet_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbEnvironmentPropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbEnvironmentPropertySet_Vtbl { pub const fn new, Impl: ITsSbEnvironmentPropertySet_Impl, const OFFSET: isize>() -> ITsSbEnvironmentPropertySet_Vtbl { Self { base__: ITsSbPropertySet_Vtbl::new::() } @@ -1472,8 +1472,8 @@ impl ITsSbGenericNotifySink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITsSbGlobalStore_Impl: Sized { fn QueryTarget(&self, providername: &::windows_core::BSTR, targetname: &::windows_core::BSTR, farmname: &::windows_core::BSTR) -> ::windows_core::Result; fn QuerySessionBySessionId(&self, providername: &::windows_core::BSTR, dwsessionid: u32, targetname: &::windows_core::BSTR) -> ::windows_core::Result; @@ -1481,11 +1481,11 @@ pub trait ITsSbGlobalStore_Impl: Sized { fn EnumerateTargets(&self, providername: &::windows_core::BSTR, farmname: &::windows_core::BSTR, envname: &::windows_core::BSTR, pdwcount: *mut u32, pval: *mut *mut ::core::option::Option) -> ::windows_core::Result<()>; fn EnumerateEnvironmentsByProvider(&self, providername: &::windows_core::BSTR, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::Result<()>; fn EnumerateSessions(&self, providername: &::windows_core::BSTR, targetname: &::windows_core::BSTR, username: &::windows_core::BSTR, userdomain: &::windows_core::BSTR, poolname: &::windows_core::BSTR, initialprogram: &::windows_core::BSTR, psessionstate: *const TSSESSION_STATE, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn GetFarmProperty(&self, farmname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetFarmProperty(&self, farmname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITsSbGlobalStore {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITsSbGlobalStore_Vtbl { pub const fn new, Impl: ITsSbGlobalStore_Impl, const OFFSET: isize>() -> ITsSbGlobalStore_Vtbl { unsafe extern "system" fn QueryTarget, Impl: ITsSbGlobalStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, providername: ::std::mem::MaybeUninit<::windows_core::BSTR>, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pptarget: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1530,7 +1530,7 @@ impl ITsSbGlobalStore_Vtbl { let this = (*this).get_impl(); this.EnumerateSessions(::core::mem::transmute(&providername), ::core::mem::transmute(&targetname), ::core::mem::transmute(&username), ::core::mem::transmute(&userdomain), ::core::mem::transmute(&poolname), ::core::mem::transmute(&initialprogram), ::core::mem::transmute_copy(&psessionstate), ::core::mem::transmute_copy(&pdwcount), ::core::mem::transmute_copy(&ppval)).into() } - unsafe extern "system" fn GetFarmProperty, Impl: ITsSbGlobalStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFarmProperty, Impl: ITsSbGlobalStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetFarmProperty(::core::mem::transmute(&farmname), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -1748,12 +1748,12 @@ impl ITsSbPluginNotifySink_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbPluginPropertySet_Impl: Sized + ITsSbPropertySet_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbPluginPropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbPluginPropertySet_Vtbl { pub const fn new, Impl: ITsSbPluginPropertySet_Impl, const OFFSET: isize>() -> ITsSbPluginPropertySet_Vtbl { Self { base__: ITsSbPropertySet_Vtbl::new::() } @@ -1762,12 +1762,12 @@ impl ITsSbPluginPropertySet_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbPropertySet_Impl: Sized + super::Com::StructuredStorage::IPropertyBag_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbPropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbPropertySet_Vtbl { pub const fn new, Impl: ITsSbPropertySet_Impl, const OFFSET: isize>() -> ITsSbPropertySet_Vtbl { Self { base__: super::Com::StructuredStorage::IPropertyBag_Vtbl::new::() } @@ -2119,8 +2119,8 @@ impl ITsSbResourcePlugin_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITsSbResourcePluginStore_Impl: Sized { fn QueryTarget(&self, targetname: &::windows_core::BSTR, farmname: &::windows_core::BSTR) -> ::windows_core::Result; fn QuerySessionBySessionId(&self, dwsessionid: u32, targetname: &::windows_core::BSTR) -> ::windows_core::Result; @@ -2134,16 +2134,16 @@ pub trait ITsSbResourcePluginStore_Impl: Sized { fn SaveTarget(&self, ptarget: ::core::option::Option<&ITsSbTarget>, bforcewrite: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SaveEnvironment(&self, penvironment: ::core::option::Option<&ITsSbEnvironment>, bforcewrite: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SaveSession(&self, psession: ::core::option::Option<&ITsSbSession>) -> ::windows_core::Result<()>; - fn SetTargetProperty(&self, targetname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetEnvironmentProperty(&self, environmentname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetTargetProperty(&self, targetname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetEnvironmentProperty(&self, environmentname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetTargetState(&self, targetname: &::windows_core::BSTR, newstate: TARGET_STATE) -> ::windows_core::Result; fn SetSessionState(&self, sbsession: ::core::option::Option<&ITsSbSession>) -> ::windows_core::Result<()>; fn EnumerateTargets(&self, farmname: &::windows_core::BSTR, envname: &::windows_core::BSTR, sortbyfieldid: TS_SB_SORT_BY, sortybypropname: &::windows_core::BSTR, pdwcount: *mut u32, pval: *mut *mut ::core::option::Option) -> ::windows_core::Result<()>; fn EnumerateSessions(&self, targetname: &::windows_core::BSTR, username: &::windows_core::BSTR, userdomain: &::windows_core::BSTR, poolname: &::windows_core::BSTR, initialprogram: &::windows_core::BSTR, psessionstate: *const TSSESSION_STATE, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn GetFarmProperty(&self, farmname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetFarmProperty(&self, farmname: &::windows_core::BSTR, propertyname: &::windows_core::BSTR, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn DeleteTarget(&self, targetname: &::windows_core::BSTR, hostname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SetTargetPropertyWithVersionCheck(&self, ptarget: ::core::option::Option<&ITsSbTarget>, propertyname: &::windows_core::BSTR, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetEnvironmentPropertyWithVersionCheck(&self, penvironment: ::core::option::Option<&ITsSbEnvironment>, propertyname: &::windows_core::BSTR, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetTargetPropertyWithVersionCheck(&self, ptarget: ::core::option::Option<&ITsSbTarget>, propertyname: &::windows_core::BSTR, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetEnvironmentPropertyWithVersionCheck(&self, penvironment: ::core::option::Option<&ITsSbEnvironment>, propertyname: &::windows_core::BSTR, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AcquireTargetLock(&self, targetname: &::windows_core::BSTR, dwtimeout: u32) -> ::windows_core::Result<::windows_core::IUnknown>; fn ReleaseTargetLock(&self, pcontext: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn TestAndSetServerState(&self, poolname: &::windows_core::BSTR, serverfqdn: &::windows_core::BSTR, newstate: TARGET_STATE, teststate: TARGET_STATE) -> ::windows_core::Result; @@ -2151,9 +2151,9 @@ pub trait ITsSbResourcePluginStore_Impl: Sized { fn GetServerState(&self, poolname: &::windows_core::BSTR, serverfqdn: &::windows_core::BSTR) -> ::windows_core::Result; fn SetServerDrainMode(&self, serverfqdn: &::windows_core::BSTR, drainmode: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITsSbResourcePluginStore {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITsSbResourcePluginStore_Vtbl { pub const fn new, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>() -> ITsSbResourcePluginStore_Vtbl { unsafe extern "system" fn QueryTarget, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pptarget: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2234,12 +2234,12 @@ impl ITsSbResourcePluginStore_Vtbl { let this = (*this).get_impl(); this.SaveSession(::windows_core::from_raw_borrowed(&psession)).into() } - unsafe extern "system" fn SetTargetProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTargetProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTargetProperty(::core::mem::transmute(&targetname), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pproperty)).into() } - unsafe extern "system" fn SetEnvironmentProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, environmentname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetEnvironmentProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, environmentname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetEnvironmentProperty(::core::mem::transmute(&environmentname), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pproperty)).into() @@ -2270,7 +2270,7 @@ impl ITsSbResourcePluginStore_Vtbl { let this = (*this).get_impl(); this.EnumerateSessions(::core::mem::transmute(&targetname), ::core::mem::transmute(&username), ::core::mem::transmute(&userdomain), ::core::mem::transmute(&poolname), ::core::mem::transmute(&initialprogram), ::core::mem::transmute_copy(&psessionstate), ::core::mem::transmute_copy(&pdwcount), ::core::mem::transmute_copy(&ppval)).into() } - unsafe extern "system" fn GetFarmProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFarmProperty, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetFarmProperty(::core::mem::transmute(&farmname), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -2280,12 +2280,12 @@ impl ITsSbResourcePluginStore_Vtbl { let this = (*this).get_impl(); this.DeleteTarget(::core::mem::transmute(&targetname), ::core::mem::transmute(&hostname)).into() } - unsafe extern "system" fn SetTargetPropertyWithVersionCheck, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptarget: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetTargetPropertyWithVersionCheck, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptarget: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetTargetPropertyWithVersionCheck(::windows_core::from_raw_borrowed(&ptarget), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pproperty)).into() } - unsafe extern "system" fn SetEnvironmentPropertyWithVersionCheck, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, penvironment: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetEnvironmentPropertyWithVersionCheck, Impl: ITsSbResourcePluginStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, penvironment: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetEnvironmentPropertyWithVersionCheck(::windows_core::from_raw_borrowed(&penvironment), ::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&pproperty)).into() @@ -2803,12 +2803,12 @@ impl ITsSbTarget_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] pub trait ITsSbTargetPropertySet_Impl: Sized + ITsSbPropertySet_Impl {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ::windows_core::RuntimeName for ITsSbTargetPropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbTargetPropertySet_Vtbl { pub const fn new, Impl: ITsSbTargetPropertySet_Impl, const OFFSET: isize>() -> ITsSbTargetPropertySet_Vtbl { Self { base__: ITsSbPropertySet_Vtbl::new::() } @@ -4918,8 +4918,8 @@ impl IWorkspaceReportMessage_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWorkspaceResTypeRegistry_Impl: Sized + super::Com::IDispatch_Impl { fn AddResourceType(&self, fmachinewide: super::super::Foundation::VARIANT_BOOL, bstrfileextension: &::windows_core::BSTR, bstrlauncher: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DeleteResourceType(&self, fmachinewide: super::super::Foundation::VARIANT_BOOL, bstrfileextension: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4927,9 +4927,9 @@ pub trait IWorkspaceResTypeRegistry_Impl: Sized + super::Com::IDispatch_Impl { fn GetResourceTypeInfo(&self, fmachinewide: super::super::Foundation::VARIANT_BOOL, bstrfileextension: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn ModifyResourceType(&self, fmachinewide: super::super::Foundation::VARIANT_BOOL, bstrfileextension: &::windows_core::BSTR, bstrlauncher: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWorkspaceResTypeRegistry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWorkspaceResTypeRegistry_Vtbl { pub const fn new, Impl: IWorkspaceResTypeRegistry_Impl, const OFFSET: isize>() -> IWorkspaceResTypeRegistry_Vtbl { unsafe extern "system" fn AddResourceType, Impl: IWorkspaceResTypeRegistry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fmachinewide: super::super::Foundation::VARIANT_BOOL, bstrfileextension: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrlauncher: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4982,8 +4982,8 @@ impl IWorkspaceResTypeRegistry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWorkspaceScriptable_Impl: Sized + super::Com::IDispatch_Impl { fn DisconnectWorkspace(&self, bstrworkspaceid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn StartWorkspace(&self, bstrworkspaceid: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, bstrworkspaceparams: &::windows_core::BSTR, ltimeout: i32, lflags: i32) -> ::windows_core::Result<()>; @@ -4993,9 +4993,9 @@ pub trait IWorkspaceScriptable_Impl: Sized + super::Com::IDispatch_Impl { fn OnAuthenticated(&self, bstrworkspaceid: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn DisconnectWorkspaceByFriendlyName(&self, bstrworkspacefriendlyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWorkspaceScriptable {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWorkspaceScriptable_Vtbl { pub const fn new, Impl: IWorkspaceScriptable_Impl, const OFFSET: isize>() -> IWorkspaceScriptable_Vtbl { unsafe extern "system" fn DisconnectWorkspace, Impl: IWorkspaceScriptable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrworkspaceid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5060,15 +5060,15 @@ impl IWorkspaceScriptable_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWorkspaceScriptable2_Impl: Sized + IWorkspaceScriptable_Impl { fn StartWorkspaceEx(&self, bstrworkspaceid: &::windows_core::BSTR, bstrworkspacefriendlyname: &::windows_core::BSTR, bstrredirectorname: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, bstrappcontainer: &::windows_core::BSTR, bstrworkspaceparams: &::windows_core::BSTR, ltimeout: i32, lflags: i32) -> ::windows_core::Result<()>; fn ResourceDismissed(&self, bstrworkspaceid: &::windows_core::BSTR, bstrworkspacefriendlyname: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWorkspaceScriptable2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWorkspaceScriptable2_Vtbl { pub const fn new, Impl: IWorkspaceScriptable2_Impl, const OFFSET: isize>() -> IWorkspaceScriptable2_Vtbl { unsafe extern "system" fn StartWorkspaceEx, Impl: IWorkspaceScriptable2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrworkspaceid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrworkspacefriendlyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrredirectorname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrusername: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrappcontainer: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrworkspaceparams: ::std::mem::MaybeUninit<::windows_core::BSTR>, ltimeout: i32, lflags: i32) -> ::windows_core::HRESULT { @@ -5091,14 +5091,14 @@ impl IWorkspaceScriptable2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWorkspaceScriptable3_Impl: Sized + IWorkspaceScriptable2_Impl { fn StartWorkspaceEx2(&self, bstrworkspaceid: &::windows_core::BSTR, bstrworkspacefriendlyname: &::windows_core::BSTR, bstrredirectorname: &::windows_core::BSTR, bstrusername: &::windows_core::BSTR, bstrpassword: &::windows_core::BSTR, bstrappcontainer: &::windows_core::BSTR, bstrworkspaceparams: &::windows_core::BSTR, ltimeout: i32, lflags: i32, bstreventloguploadaddress: &::windows_core::BSTR, correlationid: &::windows_core::GUID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWorkspaceScriptable3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWorkspaceScriptable3_Vtbl { pub const fn new, Impl: IWorkspaceScriptable3_Impl, const OFFSET: isize>() -> IWorkspaceScriptable3_Vtbl { unsafe extern "system" fn StartWorkspaceEx2, Impl: IWorkspaceScriptable3_Impl, const OFFSET: isize>( @@ -5240,12 +5240,12 @@ impl ItsPubPlugin2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _ITSWkspEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _ITSWkspEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _ITSWkspEvents_Vtbl { pub const fn new, Impl: _ITSWkspEvents_Impl, const OFFSET: isize>() -> _ITSWkspEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/mod.rs b/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/mod.rs index e99627490e..454c9ff5ca 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RemoteDesktop/mod.rs @@ -1017,22 +1017,19 @@ impl IRemoteDesktopClientSettings { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).RetrieveSettings)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRdpProperty(&self, propertyname: P0) -> ::windows_core::Result + pub unsafe fn GetRdpProperty(&self, propertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRdpProperty)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetRdpProperty(&self, propertyname: P0, value: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetRdpProperty(&self, propertyname: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetRdpProperty)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).SetRdpProperty)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), value.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1042,14 +1039,8 @@ pub struct IRemoteDesktopClientSettings_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub ApplySettings: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rdpfilecontents: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub RetrieveSettings: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rdpfilecontents: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRdpProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetRdpProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetRdpProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetRdpProperty: usize, + pub GetRdpProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetRdpProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -1286,17 +1277,14 @@ impl ITsSbClientConnection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FarmName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutContext(&self, contextid: P0, context: super::Variant::VARIANT, existingcontext: ::core::option::Option<*mut super::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn PutContext(&self, contextid: P0, context: P1, existingcontext: ::core::option::Option<*mut ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).PutContext)(::windows_core::Interface::as_raw(self), contextid.into_param().abi(), ::core::mem::transmute(context), ::core::mem::transmute(existingcontext.unwrap_or(::std::ptr::null_mut()))).ok() + (::windows_core::Interface::vtable(self).PutContext)(::windows_core::Interface::as_raw(self), contextid.into_param().abi(), context.into_param().abi(), ::core::mem::transmute(existingcontext.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetContext(&self, contextid: P0) -> ::windows_core::Result + pub unsafe fn GetContext(&self, contextid: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -1346,14 +1334,8 @@ pub struct ITsSbClientConnection_Vtbl { pub InitialProgram: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LoadBalanceResult: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FarmName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: super::Variant::VARIANT, existingcontext: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutContext: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetContext: usize, + pub PutContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: ::std::mem::MaybeUninit<::windows_core::VARIANT>, existingcontext: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, contextid: ::std::mem::MaybeUninit<::windows_core::BSTR>, context: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Environment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenvironment: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub get_ConnectionError: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SamUserAccount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1377,22 +1359,22 @@ pub struct ITsSbClientConnection_Vtbl { ::windows_core::imp::interface_hierarchy!(ITsSbClientConnectionPropertySet, ::windows_core::IUnknown, super::Com::StructuredStorage::IPropertyBag, ITsSbPropertySet); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbClientConnectionPropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -1453,22 +1435,22 @@ pub struct ITsSbEnvironment_Vtbl { ::windows_core::imp::interface_hierarchy!(ITsSbEnvironmentPropertySet, ::windows_core::IUnknown, super::Com::StructuredStorage::IPropertyBag, ITsSbPropertySet); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbEnvironmentPropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -1586,14 +1568,12 @@ impl ITsSbGlobalStore { { (::windows_core::Interface::vtable(self).EnumerateSessions)(::windows_core::Interface::as_raw(self), providername.into_param().abi(), targetname.into_param().abi(), username.into_param().abi(), userdomain.into_param().abi(), poolname.into_param().abi(), initialprogram.into_param().abi(), psessionstate, pdwcount, ppval).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFarmProperty(&self, farmname: P0, propertyname: P1, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetFarmProperty(&self, farmname: P0, propertyname: P1, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetFarmProperty)(::windows_core::Interface::as_raw(self), farmname.into_param().abi(), propertyname.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).GetFarmProperty)(::windows_core::Interface::as_raw(self), farmname.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } } #[repr(C)] @@ -1609,10 +1589,7 @@ pub struct ITsSbGlobalStore_Vtbl { pub EnumerateTargets: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, providername: ::std::mem::MaybeUninit<::windows_core::BSTR>, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, envname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwcount: *mut u32, pval: *mut *mut ::core::option::Option) -> ::windows_core::HRESULT, pub EnumerateEnvironmentsByProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, providername: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::HRESULT, pub EnumerateSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, providername: ::std::mem::MaybeUninit<::windows_core::BSTR>, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, userdomain: ::std::mem::MaybeUninit<::windows_core::BSTR>, poolname: ::std::mem::MaybeUninit<::windows_core::BSTR>, initialprogram: ::std::mem::MaybeUninit<::windows_core::BSTR>, psessionstate: *const TSSESSION_STATE, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFarmProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFarmProperty: usize, + pub GetFarmProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITsSbLoadBalanceResult, ITsSbLoadBalanceResult_Vtbl, 0x24fdb7ac_fea6_11dc_9672_9a8956d89593); ::windows_core::imp::interface_hierarchy!(ITsSbLoadBalanceResult, ::windows_core::IUnknown); @@ -1846,22 +1823,22 @@ pub struct ITsSbPluginNotifySink_Vtbl { ::windows_core::imp::interface_hierarchy!(ITsSbPluginPropertySet, ::windows_core::IUnknown, super::Com::StructuredStorage::IPropertyBag, ITsSbPropertySet); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbPluginPropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -1881,22 +1858,22 @@ pub struct ITsSbPluginPropertySet_Vtbl { ::windows_core::imp::interface_hierarchy!(ITsSbPropertySet, ::windows_core::IUnknown, super::Com::StructuredStorage::IPropertyBag); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbPropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -2274,23 +2251,19 @@ impl ITsSbResourcePluginStore { { (::windows_core::Interface::vtable(self).SaveSession)(::windows_core::Interface::as_raw(self), psession.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTargetProperty(&self, targetname: P0, propertyname: P1, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetTargetProperty(&self, targetname: P0, propertyname: P1, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetTargetProperty)(::windows_core::Interface::as_raw(self), targetname.into_param().abi(), propertyname.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).SetTargetProperty)(::windows_core::Interface::as_raw(self), targetname.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetEnvironmentProperty(&self, environmentname: P0, propertyname: P1, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetEnvironmentProperty(&self, environmentname: P0, propertyname: P1, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetEnvironmentProperty)(::windows_core::Interface::as_raw(self), environmentname.into_param().abi(), propertyname.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).SetEnvironmentProperty)(::windows_core::Interface::as_raw(self), environmentname.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } pub unsafe fn SetTargetState(&self, targetname: P0, newstate: TARGET_STATE) -> ::windows_core::Result where @@ -2323,14 +2296,12 @@ impl ITsSbResourcePluginStore { { (::windows_core::Interface::vtable(self).EnumerateSessions)(::windows_core::Interface::as_raw(self), targetname.into_param().abi(), username.into_param().abi(), userdomain.into_param().abi(), poolname.into_param().abi(), initialprogram.into_param().abi(), psessionstate, pdwcount, ppval).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFarmProperty(&self, farmname: P0, propertyname: P1, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn GetFarmProperty(&self, farmname: P0, propertyname: P1, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).GetFarmProperty)(::windows_core::Interface::as_raw(self), farmname.into_param().abi(), propertyname.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).GetFarmProperty)(::windows_core::Interface::as_raw(self), farmname.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn DeleteTarget(&self, targetname: P0, hostname: P1) -> ::windows_core::Result<()> where @@ -2339,23 +2310,19 @@ impl ITsSbResourcePluginStore { { (::windows_core::Interface::vtable(self).DeleteTarget)(::windows_core::Interface::as_raw(self), targetname.into_param().abi(), hostname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetTargetPropertyWithVersionCheck(&self, ptarget: P0, propertyname: P1, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetTargetPropertyWithVersionCheck(&self, ptarget: P0, propertyname: P1, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetTargetPropertyWithVersionCheck)(::windows_core::Interface::as_raw(self), ptarget.into_param().abi(), propertyname.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).SetTargetPropertyWithVersionCheck)(::windows_core::Interface::as_raw(self), ptarget.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetEnvironmentPropertyWithVersionCheck(&self, penvironment: P0, propertyname: P1, pproperty: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetEnvironmentPropertyWithVersionCheck(&self, penvironment: P0, propertyname: P1, pproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).SetEnvironmentPropertyWithVersionCheck)(::windows_core::Interface::as_raw(self), penvironment.into_param().abi(), propertyname.into_param().abi(), pproperty).ok() + (::windows_core::Interface::vtable(self).SetEnvironmentPropertyWithVersionCheck)(::windows_core::Interface::as_raw(self), penvironment.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(pproperty)).ok() } pub unsafe fn AcquireTargetLock(&self, targetname: P0, dwtimeout: u32) -> ::windows_core::Result<::windows_core::IUnknown> where @@ -2419,31 +2386,16 @@ pub struct ITsSbResourcePluginStore_Vtbl { pub SaveTarget: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptarget: *mut ::core::ffi::c_void, bforcewrite: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SaveEnvironment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penvironment: *mut ::core::ffi::c_void, bforcewrite: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SaveSession: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psession: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTargetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTargetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetEnvironmentProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, environmentname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetEnvironmentProperty: usize, + pub SetTargetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetEnvironmentProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, environmentname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetTargetState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, newstate: TARGET_STATE, poldstate: *mut TARGET_STATE) -> ::windows_core::HRESULT, pub SetSessionState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sbsession: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EnumerateTargets: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, envname: ::std::mem::MaybeUninit<::windows_core::BSTR>, sortbyfieldid: TS_SB_SORT_BY, sortybypropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwcount: *mut u32, pval: *mut *mut ::core::option::Option) -> ::windows_core::HRESULT, pub EnumerateSessions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, userdomain: ::std::mem::MaybeUninit<::windows_core::BSTR>, poolname: ::std::mem::MaybeUninit<::windows_core::BSTR>, initialprogram: ::std::mem::MaybeUninit<::windows_core::BSTR>, psessionstate: *const TSSESSION_STATE, pdwcount: *mut u32, ppval: *mut *mut ::core::option::Option) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFarmProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFarmProperty: usize, + pub GetFarmProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, farmname: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DeleteTarget: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, hostname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetTargetPropertyWithVersionCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptarget: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetTargetPropertyWithVersionCheck: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetEnvironmentPropertyWithVersionCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penvironment: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetEnvironmentPropertyWithVersionCheck: usize, + pub SetTargetPropertyWithVersionCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptarget: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetEnvironmentPropertyWithVersionCheck: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penvironment: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AcquireTargetLock: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetname: ::std::mem::MaybeUninit<::windows_core::BSTR>, dwtimeout: u32, ppcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ReleaseTargetLock: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcontext: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub TestAndSetServerState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, poolname: ::std::mem::MaybeUninit<::windows_core::BSTR>, serverfqdn: ::std::mem::MaybeUninit<::windows_core::BSTR>, newstate: TARGET_STATE, teststate: TARGET_STATE, pinitstate: *mut TARGET_STATE) -> ::windows_core::HRESULT, @@ -2695,22 +2647,22 @@ pub struct ITsSbTarget_Vtbl { ::windows_core::imp::interface_hierarchy!(ITsSbTargetPropertySet, ::windows_core::IUnknown, super::Com::StructuredStorage::IPropertyBag, ITsSbPropertySet); #[cfg(feature = "Win32_System_Com_StructuredStorage")] impl ITsSbTargetPropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut super::Variant::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Read(&self, pszpropname: P0, pvar: *mut ::windows_core::VARIANT, perrorlog: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar, perrorlog.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.Read)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar), perrorlog.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Write(&self, pszpropname: P0, pvar: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn Write(&self, pszpropname: P0, pvar: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).base__.base__.Write)(::windows_core::Interface::as_raw(self), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } } #[cfg(feature = "Win32_System_Com_StructuredStorage")] diff --git a/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/impl.rs b/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/impl.rs index aa8c427d04..1ca2275903 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/impl.rs @@ -1,14 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSMan_Impl: Sized + super::Com::IDispatch_Impl { fn CreateSession(&self, connection: &::windows_core::BSTR, flags: i32, connectionoptions: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result; fn CreateConnectionOptions(&self) -> ::windows_core::Result; fn CommandLine(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Error(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSMan {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSMan_Vtbl { pub const fn new, Impl: IWSMan_Impl, const OFFSET: isize>() -> IWSMan_Vtbl { unsafe extern "system" fn CreateSession, Impl: IWSMan_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, connection: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, connectionoptions: *mut ::core::ffi::c_void, session: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -67,16 +67,16 @@ impl IWSMan_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManConnectionOptions_Impl: Sized + super::Com::IDispatch_Impl { fn UserName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetUserName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetPassword(&self, password: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManConnectionOptions {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManConnectionOptions_Vtbl { pub const fn new, Impl: IWSManConnectionOptions_Impl, const OFFSET: isize>() -> IWSManConnectionOptions_Vtbl { unsafe extern "system" fn UserName, Impl: IWSManConnectionOptions_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -111,15 +111,15 @@ impl IWSManConnectionOptions_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManConnectionOptionsEx_Impl: Sized + IWSManConnectionOptions_Impl { fn CertificateThumbprint(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetCertificateThumbprint(&self, thumbprint: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManConnectionOptionsEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManConnectionOptionsEx_Vtbl { pub const fn new, Impl: IWSManConnectionOptionsEx_Impl, const OFFSET: isize>() -> IWSManConnectionOptionsEx_Vtbl { unsafe extern "system" fn CertificateThumbprint, Impl: IWSManConnectionOptionsEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, thumbprint: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -148,8 +148,8 @@ impl IWSManConnectionOptionsEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManConnectionOptionsEx2_Impl: Sized + IWSManConnectionOptionsEx_Impl { fn SetProxy(&self, accesstype: i32, authenticationmechanism: i32, username: &::windows_core::BSTR, password: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ProxyIEConfig(&self) -> ::windows_core::Result; @@ -160,9 +160,9 @@ pub trait IWSManConnectionOptionsEx2_Impl: Sized + IWSManConnectionOptionsEx_Imp fn ProxyAuthenticationUseBasic(&self) -> ::windows_core::Result; fn ProxyAuthenticationUseDigest(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManConnectionOptionsEx2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManConnectionOptionsEx2_Vtbl { pub const fn new, Impl: IWSManConnectionOptionsEx2_Impl, const OFFSET: isize>() -> IWSManConnectionOptionsEx2_Vtbl { unsafe extern "system" fn SetProxy, Impl: IWSManConnectionOptionsEx2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, accesstype: i32, authenticationmechanism: i32, username: ::std::mem::MaybeUninit<::windows_core::BSTR>, password: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -263,16 +263,16 @@ impl IWSManConnectionOptionsEx2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManEnumerator_Impl: Sized + super::Com::IDispatch_Impl { fn ReadItem(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn AtEndOfStream(&self) -> ::windows_core::Result; fn Error(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManEnumerator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManEnumerator_Vtbl { pub const fn new, Impl: IWSManEnumerator_Impl, const OFFSET: isize>() -> IWSManEnumerator_Vtbl { unsafe extern "system" fn ReadItem, Impl: IWSManEnumerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -319,8 +319,8 @@ impl IWSManEnumerator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManEx_Impl: Sized + IWSMan_Impl { fn CreateResourceLocator(&self, strresourcelocator: &::windows_core::BSTR) -> ::windows_core::Result; fn SessionFlagUTF8(&self) -> ::windows_core::Result; @@ -343,9 +343,9 @@ pub trait IWSManEx_Impl: Sized + IWSMan_Impl { fn EnumerationFlagHierarchyDeepBasePropsOnly(&self) -> ::windows_core::Result; fn EnumerationFlagReturnObject(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManEx_Vtbl { pub const fn new, Impl: IWSManEx_Impl, const OFFSET: isize>() -> IWSManEx_Vtbl { unsafe extern "system" fn CreateResourceLocator, Impl: IWSManEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strresourcelocator: ::std::mem::MaybeUninit<::windows_core::BSTR>, newresourcelocator: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -596,14 +596,14 @@ impl IWSManEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManEx2_Impl: Sized + IWSManEx_Impl { fn SessionFlagUseClientCertificate(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManEx2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManEx2_Vtbl { pub const fn new, Impl: IWSManEx2_Impl, const OFFSET: isize>() -> IWSManEx2_Vtbl { unsafe extern "system" fn SessionFlagUseClientCertificate, Impl: IWSManEx2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: *mut i32) -> ::windows_core::HRESULT { @@ -626,8 +626,8 @@ impl IWSManEx2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManEx3_Impl: Sized + IWSManEx2_Impl { fn SessionFlagUTF16(&self) -> ::windows_core::Result; fn SessionFlagUseCredSsp(&self) -> ::windows_core::Result; @@ -637,9 +637,9 @@ pub trait IWSManEx3_Impl: Sized + IWSManEx2_Impl { fn SessionFlagAllowNegotiateImplicitCredentials(&self) -> ::windows_core::Result; fn SessionFlagUseSsl(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManEx3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManEx3_Vtbl { pub const fn new, Impl: IWSManEx3_Impl, const OFFSET: isize>() -> IWSManEx3_Vtbl { unsafe extern "system" fn SessionFlagUTF16, Impl: IWSManEx3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: *mut i32) -> ::windows_core::HRESULT { @@ -734,17 +734,17 @@ impl IWSManEx3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManInternal_Impl: Sized + super::Com::IDispatch_Impl { - fn ConfigSDDL(&self, session: ::core::option::Option<&super::Com::IDispatch>, resourceuri: &super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn ConfigSDDL(&self, session: ::core::option::Option<&super::Com::IDispatch>, resourceuri: &::windows_core::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManInternal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManInternal_Vtbl { pub const fn new, Impl: IWSManInternal_Impl, const OFFSET: isize>() -> IWSManInternal_Vtbl { - unsafe extern "system" fn ConfigSDDL, Impl: IWSManInternal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, session: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn ConfigSDDL, Impl: IWSManInternal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, session: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ConfigSDDL(::windows_core::from_raw_borrowed(&session), ::core::mem::transmute(&resourceuri), ::core::mem::transmute_copy(&flags)) { @@ -761,26 +761,26 @@ impl IWSManInternal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManResourceLocator_Impl: Sized + super::Com::IDispatch_Impl { fn SetResourceURI(&self, uri: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ResourceURI(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn AddSelector(&self, resourceselname: &::windows_core::BSTR, selvalue: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddSelector(&self, resourceselname: &::windows_core::BSTR, selvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ClearSelectors(&self) -> ::windows_core::Result<()>; fn FragmentPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFragmentPath(&self, text: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn FragmentDialect(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFragmentDialect(&self, text: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddOption(&self, optionname: &::windows_core::BSTR, optionvalue: &super::Variant::VARIANT, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; + fn AddOption(&self, optionname: &::windows_core::BSTR, optionvalue: &::windows_core::VARIANT, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SetMustUnderstandOptions(&self, mustunderstand: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn MustUnderstandOptions(&self) -> ::windows_core::Result; fn ClearOptions(&self) -> ::windows_core::Result<()>; fn Error(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManResourceLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManResourceLocator_Vtbl { pub const fn new, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>() -> IWSManResourceLocator_Vtbl { unsafe extern "system" fn SetResourceURI, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -799,7 +799,7 @@ impl IWSManResourceLocator_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddSelector, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceselname: ::std::mem::MaybeUninit<::windows_core::BSTR>, selvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddSelector, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceselname: ::std::mem::MaybeUninit<::windows_core::BSTR>, selvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddSelector(::core::mem::transmute(&resourceselname), ::core::mem::transmute(&selvalue)).into() @@ -841,7 +841,7 @@ impl IWSManResourceLocator_Vtbl { let this = (*this).get_impl(); this.SetFragmentDialect(::core::mem::transmute(&text)).into() } - unsafe extern "system" fn AddOption, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: super::Variant::VARIANT, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddOption, Impl: IWSManResourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddOption(::core::mem::transmute(&optionname), ::core::mem::transmute(&optionvalue), ::core::mem::transmute_copy(&mustcomply)).into() @@ -909,15 +909,15 @@ impl IWSManResourceLocatorInternal_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSManSession_Impl: Sized + super::Com::IDispatch_Impl { - fn Get(&self, resourceuri: &super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn Put(&self, resourceuri: &super::Variant::VARIANT, resource: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn Create(&self, resourceuri: &super::Variant::VARIANT, resource: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn Delete(&self, resourceuri: &super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<()>; - fn Invoke2(&self, actionuri: &::windows_core::BSTR, resourceuri: &super::Variant::VARIANT, parameters: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; - fn Enumerate(&self, resourceuri: &super::Variant::VARIANT, filter: &::windows_core::BSTR, dialect: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result; + fn Get(&self, resourceuri: &::windows_core::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn Put(&self, resourceuri: &::windows_core::VARIANT, resource: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn Create(&self, resourceuri: &::windows_core::VARIANT, resource: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn Delete(&self, resourceuri: &::windows_core::VARIANT, flags: i32) -> ::windows_core::Result<()>; + fn Invoke2(&self, actionuri: &::windows_core::BSTR, resourceuri: &::windows_core::VARIANT, parameters: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn Enumerate(&self, resourceuri: &::windows_core::VARIANT, filter: &::windows_core::BSTR, dialect: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result; fn Identify(&self, flags: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn Error(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn BatchItems(&self) -> ::windows_core::Result; @@ -925,12 +925,12 @@ pub trait IWSManSession_Impl: Sized + super::Com::IDispatch_Impl { fn Timeout(&self) -> ::windows_core::Result; fn SetTimeout(&self, value: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSManSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSManSession_Vtbl { pub const fn new, Impl: IWSManSession_Impl, const OFFSET: isize>() -> IWSManSession_Vtbl { - unsafe extern "system" fn Get, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn Get, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Get(::core::mem::transmute(&resourceuri), ::core::mem::transmute_copy(&flags)) { @@ -941,7 +941,7 @@ impl IWSManSession_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Put, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultresource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn Put, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultresource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Put(::core::mem::transmute(&resourceuri), ::core::mem::transmute(&resource), ::core::mem::transmute_copy(&flags)) { @@ -952,7 +952,7 @@ impl IWSManSession_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Create, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, newuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn Create, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, newuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Create(::core::mem::transmute(&resourceuri), ::core::mem::transmute(&resource), ::core::mem::transmute_copy(&flags)) { @@ -963,12 +963,12 @@ impl IWSManSession_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Delete, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Delete, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Delete(::core::mem::transmute(&resourceuri), ::core::mem::transmute_copy(&flags)).into() } - unsafe extern "system" fn Invoke2, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, actionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, resourceuri: super::Variant::VARIANT, parameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, result: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn Invoke2, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, actionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, parameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, result: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Invoke2(::core::mem::transmute(&actionuri), ::core::mem::transmute(&resourceuri), ::core::mem::transmute(¶meters), ::core::mem::transmute_copy(&flags)) { @@ -979,7 +979,7 @@ impl IWSManSession_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Enumerate, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, filter: ::std::mem::MaybeUninit<::windows_core::BSTR>, dialect: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Enumerate, Impl: IWSManSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, filter: ::std::mem::MaybeUninit<::windows_core::BSTR>, dialect: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Enumerate(::core::mem::transmute(&resourceuri), ::core::mem::transmute(&filter), ::core::mem::transmute(&dialect), ::core::mem::transmute_copy(&flags)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/mod.rs b/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/mod.rs index f7fd599dfd..b63ad9651c 100644 --- a/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/RemoteManagement/mod.rs @@ -996,14 +996,15 @@ pub struct IWSManEx3_Vtbl { ::windows_core::imp::interface_hierarchy!(IWSManInternal, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IWSManInternal { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConfigSDDL(&self, session: P0, resourceuri: super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn ConfigSDDL(&self, session: P0, resourceuri: P1, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ConfigSDDL)(::windows_core::Interface::as_raw(self), session.into_param().abi(), ::core::mem::transmute(resourceuri), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ConfigSDDL)(::windows_core::Interface::as_raw(self), session.into_param().abi(), resourceuri.into_param().abi(), flags, &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -1011,9 +1012,9 @@ impl IWSManInternal { #[doc(hidden)] pub struct IWSManInternal_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ConfigSDDL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, session: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub ConfigSDDL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, session: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] ConfigSDDL: usize, } #[cfg(feature = "Win32_System_Com")] @@ -1037,13 +1038,12 @@ impl IWSManResourceLocator { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ResourceURI)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddSelector(&self, resourceselname: P0, selvalue: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddSelector(&self, resourceselname: P0, selvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddSelector)(::windows_core::Interface::as_raw(self), resourceselname.into_param().abi(), ::core::mem::transmute(selvalue)).ok() + (::windows_core::Interface::vtable(self).AddSelector)(::windows_core::Interface::as_raw(self), resourceselname.into_param().abi(), selvalue.into_param().abi()).ok() } pub unsafe fn ClearSelectors(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ClearSelectors)(::windows_core::Interface::as_raw(self)).ok() @@ -1068,14 +1068,13 @@ impl IWSManResourceLocator { { (::windows_core::Interface::vtable(self).SetFragmentDialect)(::windows_core::Interface::as_raw(self), text.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddOption(&self, optionname: P0, optionvalue: super::Variant::VARIANT, mustcomply: P1) -> ::windows_core::Result<()> + pub unsafe fn AddOption(&self, optionname: P0, optionvalue: P1, mustcomply: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, - P1: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).AddOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), ::core::mem::transmute(optionvalue), mustcomply.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).AddOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), optionvalue.into_param().abi(), mustcomply.into_param().abi()).ok() } pub unsafe fn SetMustUnderstandOptions(&self, mustunderstand: P0) -> ::windows_core::Result<()> where @@ -1102,19 +1101,13 @@ pub struct IWSManResourceLocator_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub SetResourceURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ResourceURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddSelector: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceselname: ::std::mem::MaybeUninit<::windows_core::BSTR>, selvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddSelector: usize, + pub AddSelector: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceselname: ::std::mem::MaybeUninit<::windows_core::BSTR>, selvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ClearSelectors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FragmentPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetFragmentPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub FragmentDialect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetFragmentDialect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: super::Variant::VARIANT, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddOption: usize, + pub AddOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, mustcomply: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub SetMustUnderstandOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mustunderstand: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub MustUnderstandOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mustunderstand: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub ClearOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1139,54 +1132,54 @@ pub struct IWSManResourceLocatorInternal_Vtbl { ::windows_core::imp::interface_hierarchy!(IWSManSession, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IWSManSession { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, resourceuri: super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn Get(&self, resourceuri: P0, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resourceuri), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), resourceuri.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, resourceuri: super::Variant::VARIANT, resource: P0, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> + pub unsafe fn Put(&self, resourceuri: P0, resource: P1, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resourceuri), resource.into_param().abi(), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), resourceuri.into_param().abi(), resource.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Create(&self, resourceuri: super::Variant::VARIANT, resource: P0, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> + pub unsafe fn Create(&self, resourceuri: P0, resource: P1, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resourceuri), resource.into_param().abi(), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), resourceuri.into_param().abi(), resource.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Delete(&self, resourceuri: super::Variant::VARIANT, flags: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resourceuri), flags).ok() + pub unsafe fn Delete(&self, resourceuri: P0, flags: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), resourceuri.into_param().abi(), flags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Invoke2(&self, actionuri: P0, resourceuri: super::Variant::VARIANT, parameters: P1, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> + pub unsafe fn Invoke2(&self, actionuri: P0, resourceuri: P1, parameters: P2, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, - P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Invoke2)(::windows_core::Interface::as_raw(self), actionuri.into_param().abi(), ::core::mem::transmute(resourceuri), parameters.into_param().abi(), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Invoke2)(::windows_core::Interface::as_raw(self), actionuri.into_param().abi(), resourceuri.into_param().abi(), parameters.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Enumerate(&self, resourceuri: super::Variant::VARIANT, filter: P0, dialect: P1, flags: i32) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Enumerate(&self, resourceuri: P0, filter: P1, dialect: P2, flags: i32) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Enumerate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(resourceuri), filter.into_param().abi(), dialect.into_param().abi(), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Enumerate)(::windows_core::Interface::as_raw(self), resourceuri.into_param().abi(), filter.into_param().abi(), dialect.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn Identify(&self, flags: i32) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -1216,29 +1209,14 @@ impl IWSManSession { #[doc(hidden)] pub struct IWSManSession_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Get: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultresource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Put: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, newuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Create: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, flags: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Delete: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Invoke2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, actionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, resourceuri: super::Variant::VARIANT, parameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, result: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Invoke2: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Enumerate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: super::Variant::VARIANT, filter: ::std::mem::MaybeUninit<::windows_core::BSTR>, dialect: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, resource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultresource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, resource: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, newuri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32) -> ::windows_core::HRESULT, + pub Invoke2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, actionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, parameters: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, result: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub Enumerate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, resourceuri: ::std::mem::MaybeUninit<::windows_core::VARIANT>, filter: ::std::mem::MaybeUninit<::windows_core::BSTR>, dialect: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, resultset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Enumerate: usize, pub Identify: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: i32, result: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Error: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, diff --git a/crates/libs/windows/src/Windows/Win32/System/Search/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Search/impl.rs index a4eb8694db..f8015c2dce 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Search/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Search/impl.rs @@ -98,12 +98,12 @@ impl DataSourceListener_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DataSourceObject_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DataSourceObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DataSourceObject_Vtbl { pub const fn new, Impl: DataSourceObject_Impl, const OFFSET: isize>() -> DataSourceObject_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -157,14 +157,14 @@ impl IAccessor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IAlterIndex_Impl: Sized { fn AlterIndex(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, pnewindexid: *const super::super::Storage::IndexServer::DBID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IAlterIndex {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IAlterIndex_Vtbl { pub const fn new, Impl: IAlterIndex_Impl, const OFFSET: isize>() -> IAlterIndex_Vtbl { unsafe extern "system" fn AlterIndex, Impl: IAlterIndex_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, pnewindexid: *const super::super::Storage::IndexServer::DBID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -178,15 +178,15 @@ impl IAlterIndex_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub trait IAlterTable_Impl: Sized { fn AlterColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID, dwcolumndescflags: u32, pcolumndesc: *const DBCOLUMNDESC) -> ::windows_core::Result<()>; fn AlterTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pnewtableid: *const super::super::Storage::IndexServer::DBID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IAlterTable {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl IAlterTable_Vtbl { pub const fn new, Impl: IAlterTable_Impl, const OFFSET: isize>() -> IAlterTable_Vtbl { unsafe extern "system" fn AlterColumn, Impl: IAlterTable_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID, dwcolumndescflags: u32, pcolumndesc: *const DBCOLUMNDESC) -> ::windows_core::HRESULT { @@ -377,15 +377,15 @@ impl IColumnsInfo2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IColumnsRowset_Impl: Sized { fn GetAvailableColumns(&self, pcoptcolumns: *mut usize, prgoptcolumns: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; fn GetColumnsRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, coptcolumns: usize, rgoptcolumns: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, ppcolrowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IColumnsRowset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IColumnsRowset_Vtbl { pub const fn new, Impl: IColumnsRowset_Impl, const OFFSET: isize>() -> IColumnsRowset_Vtbl { unsafe extern "system" fn GetAvailableColumns, Impl: IColumnsRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcoptcolumns: *mut usize, prgoptcolumns: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT { @@ -581,15 +581,15 @@ impl ICommandPrepare_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait ICommandProperties_Impl: Sized { fn GetProperties(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; fn SetProperties(&self, cpropertysets: u32, rgpropertysets: *const DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for ICommandProperties {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ICommandProperties_Vtbl { pub const fn new, Impl: ICommandProperties_Impl, const OFFSET: isize>() -> ICommandProperties_Vtbl { unsafe extern "system" fn GetProperties, Impl: ICommandProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -731,20 +731,20 @@ impl ICommandWithParameters_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] pub trait ICondition_Impl: Sized + super::Com::IPersistStream_Impl { fn GetConditionType(&self) -> ::windows_core::Result; fn GetSubConditions(&self, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn GetComparisonInfo(&self, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetComparisonInfo(&self, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetValueType(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetValueNormalization(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetInputTerms(&self, pppropertyterm: *mut ::core::option::Option, ppoperationterm: *mut ::core::option::Option, ppvalueterm: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl ::windows_core::RuntimeName for ICondition {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl ICondition_Vtbl { pub const fn new, Impl: ICondition_Impl, const OFFSET: isize>() -> ICondition_Vtbl { unsafe extern "system" fn GetConditionType, Impl: ICondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pnodetype: *mut Common::CONDITION_TYPE) -> ::windows_core::HRESULT { @@ -763,7 +763,7 @@ impl ICondition_Vtbl { let this = (*this).get_impl(); this.GetSubConditions(::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn GetComparisonInfo, Impl: ICondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetComparisonInfo, Impl: ICondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetComparisonInfo(::core::mem::transmute_copy(&ppszpropertyname), ::core::mem::transmute_copy(&pcop), ::core::mem::transmute_copy(&ppropvar)).into() @@ -821,15 +821,15 @@ impl ICondition_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait ICondition2_Impl: Sized + ICondition_Impl { fn GetLocale(&self) -> ::windows_core::Result<::windows_core::PWSTR>; - fn GetLeafConditionInfo(&self, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetLeafConditionInfo(&self, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for ICondition2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ICondition2_Vtbl { pub const fn new, Impl: ICondition2_Impl, const OFFSET: isize>() -> ICondition2_Vtbl { unsafe extern "system" fn GetLocale, Impl: ICondition2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszlocalename: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -843,7 +843,7 @@ impl ICondition2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetLeafConditionInfo, Impl: ICondition2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetLeafConditionInfo, Impl: ICondition2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetLeafConditionInfo(::core::mem::transmute_copy(&ppropkey), ::core::mem::transmute_copy(&pcop), ::core::mem::transmute_copy(&ppropvar)).into() @@ -858,17 +858,17 @@ impl ICondition2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] pub trait IConditionFactory_Impl: Sized { fn MakeNot(&self, pcsub: ::core::option::Option<&ICondition>, fsimplify: super::super::Foundation::BOOL) -> ::windows_core::Result; fn MakeAndOr(&self, ct: Common::CONDITION_TYPE, peusubs: ::core::option::Option<&super::Com::IEnumUnknown>, fsimplify: super::super::Foundation::BOOL) -> ::windows_core::Result; - fn MakeLeaf(&self, pszpropertyname: &::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: &::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: ::core::option::Option<&IRichChunk>, poperationterm: ::core::option::Option<&IRichChunk>, pvalueterm: ::core::option::Option<&IRichChunk>, fexpand: super::super::Foundation::BOOL) -> ::windows_core::Result; + fn MakeLeaf(&self, pszpropertyname: &::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: &::windows_core::PCWSTR, ppropvar: *const ::windows_core::PROPVARIANT, ppropertynameterm: ::core::option::Option<&IRichChunk>, poperationterm: ::core::option::Option<&IRichChunk>, pvalueterm: ::core::option::Option<&IRichChunk>, fexpand: super::super::Foundation::BOOL) -> ::windows_core::Result; fn Resolve(&self, pc: ::core::option::Option<&ICondition>, sqro: STRUCTURED_QUERY_RESOLVE_OPTION, pstreferencetime: *const super::super::Foundation::SYSTEMTIME) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl ::windows_core::RuntimeName for IConditionFactory {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl IConditionFactory_Vtbl { pub const fn new, Impl: IConditionFactory_Impl, const OFFSET: isize>() -> IConditionFactory_Vtbl { unsafe extern "system" fn MakeNot, Impl: IConditionFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcsub: *mut ::core::ffi::c_void, fsimplify: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -893,7 +893,7 @@ impl IConditionFactory_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MakeLeaf, Impl: IConditionFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropertyname: ::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, fexpand: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn MakeLeaf, Impl: IConditionFactory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpropertyname: ::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, fexpand: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MakeLeaf(::core::mem::transmute(&pszpropertyname), ::core::mem::transmute_copy(&cop), ::core::mem::transmute(&pszvaluetype), ::core::mem::transmute_copy(&ppropvar), ::windows_core::from_raw_borrowed(&ppropertynameterm), ::windows_core::from_raw_borrowed(&poperationterm), ::windows_core::from_raw_borrowed(&pvalueterm), ::core::mem::transmute_copy(&fexpand)) { @@ -927,8 +927,8 @@ impl IConditionFactory_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IConditionFactory2_Impl: Sized + IConditionFactory_Impl { fn CreateTrueFalse(&self, fval: super::super::Foundation::BOOL, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn CreateNegation(&self, pcsub: ::core::option::Option<&ICondition>, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; @@ -937,12 +937,12 @@ pub trait IConditionFactory2_Impl: Sized + IConditionFactory_Impl { fn CreateStringLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, pszvalue: &::windows_core::PCWSTR, pszlocalename: &::windows_core::PCWSTR, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn CreateIntegerLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, lvalue: i32, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn CreateBooleanLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, fvalue: super::super::Foundation::BOOL, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn CreateLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const super::Com::StructuredStorage::PROPVARIANT, pszsemantictype: &::windows_core::PCWSTR, pszlocalename: &::windows_core::PCWSTR, ppropertynameterm: ::core::option::Option<&IRichChunk>, poperationterm: ::core::option::Option<&IRichChunk>, pvalueterm: ::core::option::Option<&IRichChunk>, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; + fn CreateLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const ::windows_core::PROPVARIANT, pszsemantictype: &::windows_core::PCWSTR, pszlocalename: &::windows_core::PCWSTR, ppropertynameterm: ::core::option::Option<&IRichChunk>, poperationterm: ::core::option::Option<&IRichChunk>, pvalueterm: ::core::option::Option<&IRichChunk>, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn ResolveCondition(&self, pc: ::core::option::Option<&ICondition>, sqro: STRUCTURED_QUERY_RESOLVE_OPTION, pstreferencetime: *const super::super::Foundation::SYSTEMTIME, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IConditionFactory2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IConditionFactory2_Vtbl { pub const fn new, Impl: IConditionFactory2_Impl, const OFFSET: isize>() -> IConditionFactory2_Vtbl { unsafe extern "system" fn CreateTrueFalse, Impl: IConditionFactory2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fval: super::super::Foundation::BOOL, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -980,7 +980,7 @@ impl IConditionFactory2_Vtbl { let this = (*this).get_impl(); this.CreateBooleanLeaf(::core::mem::transmute_copy(&propkey), ::core::mem::transmute_copy(&cop), ::core::mem::transmute_copy(&fvalue), ::core::mem::transmute_copy(&cco), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn CreateLeaf, Impl: IConditionFactory2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const super::Com::StructuredStorage::PROPVARIANT, pszsemantictype: ::windows_core::PCWSTR, pszlocalename: ::windows_core::PCWSTR, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateLeaf, Impl: IConditionFactory2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pszsemantictype: ::windows_core::PCWSTR, pszlocalename: ::windows_core::PCWSTR, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CreateLeaf(::core::mem::transmute_copy(&propkey), ::core::mem::transmute_copy(&cop), ::core::mem::transmute_copy(&propvar), ::core::mem::transmute(&pszsemantictype), ::core::mem::transmute(&pszlocalename), ::windows_core::from_raw_borrowed(&ppropertynameterm), ::windows_core::from_raw_borrowed(&poperationterm), ::windows_core::from_raw_borrowed(&pvalueterm), ::core::mem::transmute_copy(&cco), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() @@ -1007,17 +1007,17 @@ impl IConditionFactory2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] pub trait IConditionGenerator_Impl: Sized { fn Initialize(&self, pschemaprovider: ::core::option::Option<&ISchemaProvider>) -> ::windows_core::Result<()>; fn RecognizeNamedEntities(&self, pszinputstring: &::windows_core::PCWSTR, lciduserlocale: u32, ptokencollection: ::core::option::Option<&ITokenCollection>, pnamedentities: ::core::option::Option<&INamedEntityCollector>) -> ::windows_core::Result<()>; fn GenerateForLeaf(&self, pconditionfactory: ::core::option::Option<&IConditionFactory>, pszpropertyname: &::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: &::windows_core::PCWSTR, pszvalue: &::windows_core::PCWSTR, pszvalue2: &::windows_core::PCWSTR, ppropertynameterm: ::core::option::Option<&IRichChunk>, poperationterm: ::core::option::Option<&IRichChunk>, pvalueterm: ::core::option::Option<&IRichChunk>, automaticwildcard: super::super::Foundation::BOOL, pnostringquery: *mut super::super::Foundation::BOOL, ppqueryexpression: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn DefaultPhrase(&self, pszvaluetype: &::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; + fn DefaultPhrase(&self, pszvaluetype: &::windows_core::PCWSTR, ppropvar: *const ::windows_core::PROPVARIANT, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl ::windows_core::RuntimeName for IConditionGenerator {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl IConditionGenerator_Vtbl { pub const fn new, Impl: IConditionGenerator_Impl, const OFFSET: isize>() -> IConditionGenerator_Vtbl { unsafe extern "system" fn Initialize, Impl: IConditionGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pschemaprovider: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1049,7 +1049,7 @@ impl IConditionGenerator_Vtbl { ) .into() } - unsafe extern "system" fn DefaultPhrase, Impl: IConditionGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn DefaultPhrase, Impl: IConditionGenerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.DefaultPhrase(::core::mem::transmute(&pszvaluetype), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&fuseenglish), ::core::mem::transmute_copy(&ppszphrase)).into() @@ -1165,14 +1165,14 @@ impl IDBAsynchStatus_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Variant\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] pub trait IDBBinderProperties_Impl: Sized + IDBProperties_Impl { fn Reset(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDBBinderProperties {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl IDBBinderProperties_Vtbl { pub const fn new, Impl: IDBBinderProperties_Impl, const OFFSET: isize>() -> IDBBinderProperties_Vtbl { unsafe extern "system" fn Reset, Impl: IDBBinderProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1232,17 +1232,17 @@ impl IDBCreateSession_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Variant\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] pub trait IDBDataSourceAdmin_Impl: Sized { fn CreateDataSource(&self, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, punkouter: ::core::option::Option<&::windows_core::IUnknown>, riid: *const ::windows_core::GUID, ppdbsession: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn DestroyDataSource(&self) -> ::windows_core::Result<()>; fn GetCreationProperties(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: *mut *mut u16) -> ::windows_core::Result<()>; fn ModifyDataSource(&self, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDBDataSourceAdmin {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl IDBDataSourceAdmin_Vtbl { pub const fn new, Impl: IDBDataSourceAdmin_Impl, const OFFSET: isize>() -> IDBDataSourceAdmin_Vtbl { unsafe extern "system" fn CreateDataSource, Impl: IDBDataSourceAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, punkouter: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppdbsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1370,16 +1370,16 @@ impl IDBPromptInitialize_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Variant\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] pub trait IDBProperties_Impl: Sized { fn GetProperties(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; fn GetPropertyInfo(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: *mut *mut u16) -> ::windows_core::Result<()>; fn SetProperties(&self, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDBProperties {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Variant"))] impl IDBProperties_Vtbl { pub const fn new, Impl: IDBProperties_Impl, const OFFSET: isize>() -> IDBProperties_Vtbl { unsafe extern "system" fn GetProperties, Impl: IDBProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -1441,18 +1441,18 @@ impl IDBSchemaCommand_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IDBSchemaRowset_Impl: Sized { - fn GetRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const super::Variant::VARIANT, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; + fn GetRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const ::windows_core::VARIANT, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn GetSchemas(&self, pcschemas: *mut u32, prgschemas: *mut *mut ::windows_core::GUID, prgrestrictionsupport: *mut *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IDBSchemaRowset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IDBSchemaRowset_Vtbl { pub const fn new, Impl: IDBSchemaRowset_Impl, const OFFSET: isize>() -> IDBSchemaRowset_Vtbl { - unsafe extern "system" fn GetRowset, Impl: IDBSchemaRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const super::Variant::VARIANT, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRowset, Impl: IDBSchemaRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetRowset(::windows_core::from_raw_borrowed(&punkouter), ::core::mem::transmute_copy(&rguidschema), ::core::mem::transmute_copy(&crestrictions), ::core::mem::transmute_copy(&rgrestrictions), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&cpropertysets), ::core::mem::transmute_copy(&rgpropertysets), ::core::mem::transmute_copy(&pprowset)).into() @@ -1472,15 +1472,11 @@ impl IDBSchemaRowset_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDCInfo_Impl: Sized { fn GetInfo(&self, cinfo: u32, rgeinfotype: *const u32, prginfo: *mut *mut DCINFO) -> ::windows_core::Result<()>; fn SetInfo(&self, cinfo: u32, rginfo: *const DCINFO) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDCInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDCInfo_Vtbl { pub const fn new, Impl: IDCInfo_Impl, const OFFSET: isize>() -> IDCInfo_Vtbl { unsafe extern "system" fn GetInfo, Impl: IDCInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cinfo: u32, rgeinfotype: *const u32, prginfo: *mut *mut DCINFO) -> ::windows_core::HRESULT { @@ -1628,17 +1624,17 @@ impl IDataInitialize_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDataSourceLocator_Impl: Sized + super::Com::IDispatch_Impl { fn hWnd(&self) -> ::windows_core::Result; fn SethWnd(&self, hwndparent: super::super::Foundation::HWND) -> ::windows_core::Result<()>; fn PromptNew(&self) -> ::windows_core::Result; fn PromptEdit(&self, ppadoconnection: *mut ::core::option::Option, pbsuccess: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDataSourceLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDataSourceLocator_Vtbl { pub const fn new, Impl: IDataSourceLocator_Impl, const OFFSET: isize>() -> IDataSourceLocator_Vtbl { unsafe extern "system" fn hWnd, Impl: IDataSourceLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phwndparent: *mut super::super::Foundation::HWND) -> ::windows_core::HRESULT { @@ -1772,8 +1768,6 @@ impl IEntity_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumItemProperties_Impl: Sized { fn Next(&self, celt: u32, rgelt: *mut ITEMPROP, pceltfetched: *mut u32) -> ::windows_core::Result<()>; fn Skip(&self, celt: u32) -> ::windows_core::Result<()>; @@ -1781,9 +1775,7 @@ pub trait IEnumItemProperties_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn GetCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumItemProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumItemProperties_Vtbl { pub const fn new, Impl: IEnumItemProperties_Impl, const OFFSET: isize>() -> IEnumItemProperties_Vtbl { unsafe extern "system" fn Next, Impl: IEnumItemProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, celt: u32, rgelt: *mut ITEMPROP, pceltfetched: *mut u32) -> ::windows_core::HRESULT { @@ -1990,16 +1982,16 @@ impl IEnumSubscription_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IErrorLookup_Impl: Sized { fn GetErrorDescription(&self, hrerror: ::windows_core::HRESULT, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, lcid: u32, pbstrsource: *mut ::windows_core::BSTR, pbstrdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetHelpInfo(&self, hrerror: ::windows_core::HRESULT, dwlookupid: u32, lcid: u32, pbstrhelpfile: *mut ::windows_core::BSTR, pdwhelpcontext: *mut u32) -> ::windows_core::Result<()>; fn ReleaseErrors(&self, dwdynamicerrorid: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IErrorLookup {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IErrorLookup_Vtbl { pub const fn new, Impl: IErrorLookup_Impl, const OFFSET: isize>() -> IErrorLookup_Vtbl { unsafe extern "system" fn GetErrorDescription, Impl: IErrorLookup_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hrerror: ::windows_core::HRESULT, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, lcid: u32, pbstrsource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2028,8 +2020,8 @@ impl IErrorLookup_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IErrorRecords_Impl: Sized { fn AddErrorRecord(&self, perrorinfo: *const ERRORINFO, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, punkcustomerror: ::core::option::Option<&::windows_core::IUnknown>, dwdynamicerrorid: u32) -> ::windows_core::Result<()>; fn GetBasicErrorInfo(&self, ulrecordnum: u32, perrorinfo: *mut ERRORINFO) -> ::windows_core::Result<()>; @@ -2038,9 +2030,9 @@ pub trait IErrorRecords_Impl: Sized { fn GetErrorParameters(&self, ulrecordnum: u32) -> ::windows_core::Result; fn GetRecordCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IErrorRecords {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IErrorRecords_Vtbl { pub const fn new, Impl: IErrorRecords_Impl, const OFFSET: isize>() -> IErrorRecords_Vtbl { unsafe extern "system" fn AddErrorRecord, Impl: IErrorRecords_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, perrorinfo: *const ERRORINFO, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, punkcustomerror: *mut ::core::ffi::c_void, dwdynamicerrorid: u32) -> ::windows_core::HRESULT { @@ -2219,15 +2211,15 @@ impl IGetSourceRow_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IIndexDefinition_Impl: Sized { fn CreateIndex(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, cindexcolumndescs: usize, rgindexcolumndescs: *const DBINDEXCOLUMNDESC, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, ppindexid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; fn DropIndex(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IIndexDefinition {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IIndexDefinition_Vtbl { pub const fn new, Impl: IIndexDefinition_Impl, const OFFSET: isize>() -> IIndexDefinition_Vtbl { unsafe extern "system" fn CreateIndex, Impl: IIndexDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, cindexcolumndescs: usize, rgindexcolumndescs: *const DBINDEXCOLUMNDESC, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, ppindexid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT { @@ -2250,17 +2242,13 @@ impl IIndexDefinition_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IInterval_Impl: Sized { - fn GetLimits(&self, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut super::Com::StructuredStorage::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetLimits(&self, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut ::windows_core::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IInterval {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IInterval_Vtbl { pub const fn new, Impl: IInterval_Impl, const OFFSET: isize>() -> IInterval_Vtbl { - unsafe extern "system" fn GetLimits, Impl: IInterval_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut super::Com::StructuredStorage::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetLimits, Impl: IInterval_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetLimits(::core::mem::transmute_copy(&pilklower), ::core::mem::transmute_copy(&ppropvarlower), ::core::mem::transmute_copy(&pilkupper), ::core::mem::transmute_copy(&ppropvarupper)).into() @@ -2333,8 +2321,8 @@ impl ILoadFilterWithPrivateComActivation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IMDDataset_Impl: Sized { fn FreeAxisInfo(&self, caxes: usize, rgaxisinfo: *const MDAXISINFO) -> ::windows_core::Result<()>; fn GetAxisInfo(&self, pcaxes: *mut usize, prgaxisinfo: *mut *mut MDAXISINFO) -> ::windows_core::Result<()>; @@ -2342,9 +2330,9 @@ pub trait IMDDataset_Impl: Sized { fn GetCellData(&self, haccessor: HACCESSOR, ulstartcell: usize, ulendcell: usize, pdata: *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetSpecification(&self, riid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IMDDataset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IMDDataset_Vtbl { pub const fn new, Impl: IMDDataset_Impl, const OFFSET: isize>() -> IMDDataset_Vtbl { unsafe extern "system" fn FreeAxisInfo, Impl: IMDDataset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, caxes: usize, rgaxisinfo: *const MDAXISINFO) -> ::windows_core::HRESULT { @@ -2430,14 +2418,14 @@ impl IMDFind_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IMDRangeRowset_Impl: Sized { fn GetRangeRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, ulstartcell: usize, ulendcell: usize, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IMDRangeRowset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IMDRangeRowset_Vtbl { pub const fn new, Impl: IMDRangeRowset_Impl, const OFFSET: isize>() -> IMDRangeRowset_Vtbl { unsafe extern "system" fn GetRangeRowset, Impl: IMDRangeRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ulstartcell: usize, ulendcell: usize, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2651,14 +2639,14 @@ impl IOpLockStatus_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IOpenRowset_Impl: Sized { fn OpenRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IOpenRowset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IOpenRowset_Vtbl { pub const fn new, Impl: IOpenRowset_Impl, const OFFSET: isize>() -> IOpenRowset_Vtbl { unsafe extern "system" fn OpenRowset, Impl: IOpenRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2749,21 +2737,21 @@ impl IProvideMoniker_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IQueryParser_Impl: Sized { fn Parse(&self, pszinputstring: &::windows_core::PCWSTR, pcustomproperties: ::core::option::Option<&super::Com::IEnumUnknown>) -> ::windows_core::Result; - fn SetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION) -> ::windows_core::Result; - fn SetMultiOption(&self, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: &::windows_core::PCWSTR, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetMultiOption(&self, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: &::windows_core::PCWSTR, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetSchemaProvider(&self) -> ::windows_core::Result; fn RestateToString(&self, pcondition: ::core::option::Option<&ICondition>, fuseenglish: super::super::Foundation::BOOL) -> ::windows_core::Result<::windows_core::PWSTR>; fn ParsePropertyValue(&self, pszpropertyname: &::windows_core::PCWSTR, pszinputstring: &::windows_core::PCWSTR) -> ::windows_core::Result; fn RestatePropertyValueToString(&self, pcondition: ::core::option::Option<&ICondition>, fuseenglish: super::super::Foundation::BOOL, ppszpropertyname: *mut ::windows_core::PWSTR, ppszquerystring: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IQueryParser {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IQueryParser_Vtbl { pub const fn new, Impl: IQueryParser_Impl, const OFFSET: isize>() -> IQueryParser_Vtbl { unsafe extern "system" fn Parse, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszinputstring: ::windows_core::PCWSTR, pcustomproperties: *mut ::core::ffi::c_void, ppsolution: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2777,12 +2765,12 @@ impl IQueryParser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOption(::core::mem::transmute_copy(&option), ::core::mem::transmute_copy(&poptionvalue)).into() } - unsafe extern "system" fn GetOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetOption(::core::mem::transmute_copy(&option)) { @@ -2793,7 +2781,7 @@ impl IQueryParser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetMultiOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: ::windows_core::PCWSTR, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetMultiOption, Impl: IQueryParser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: ::windows_core::PCWSTR, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetMultiOption(::core::mem::transmute_copy(&option), ::core::mem::transmute(&pszoptionkey), ::core::mem::transmute_copy(&poptionvalue)).into() @@ -2852,16 +2840,12 @@ impl IQueryParser_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IQueryParserManager_Impl: Sized { fn CreateLoadedParser(&self, pszcatalog: &::windows_core::PCWSTR, langidforkeywords: u16, riid: *const ::windows_core::GUID, ppqueryparser: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn InitializeOptions(&self, funderstandnqs: super::super::Foundation::BOOL, fautowildcard: super::super::Foundation::BOOL, pqueryparser: ::core::option::Option<&IQueryParser>) -> ::windows_core::Result<()>; - fn SetOption(&self, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn SetOption(&self, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IQueryParserManager {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IQueryParserManager_Vtbl { pub const fn new, Impl: IQueryParserManager_Impl, const OFFSET: isize>() -> IQueryParserManager_Vtbl { unsafe extern "system" fn CreateLoadedParser, Impl: IQueryParserManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszcatalog: ::windows_core::PCWSTR, langidforkeywords: u16, riid: *const ::windows_core::GUID, ppqueryparser: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2874,7 +2858,7 @@ impl IQueryParserManager_Vtbl { let this = (*this).get_impl(); this.InitializeOptions(::core::mem::transmute_copy(&funderstandnqs), ::core::mem::transmute_copy(&fautowildcard), ::windows_core::from_raw_borrowed(&pqueryparser)).into() } - unsafe extern "system" fn SetOption, Impl: IQueryParserManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOption, Impl: IQueryParserManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOption(::core::mem::transmute_copy(&option), ::core::mem::transmute_copy(&poptionvalue)).into() @@ -2890,16 +2874,16 @@ impl IQueryParserManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] pub trait IQuerySolution_Impl: Sized + IConditionFactory_Impl { fn GetQuery(&self, ppquerynode: *mut ::core::option::Option, ppmaintype: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GetErrors(&self, riid: *const ::windows_core::GUID, ppparseerrors: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetLexicalData(&self, ppszinputstring: *mut ::windows_core::PWSTR, pptokens: *mut ::core::option::Option, plcid: *mut u32, ppwordbreaker: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl ::windows_core::RuntimeName for IQuerySolution {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] impl IQuerySolution_Vtbl { pub const fn new, Impl: IQuerySolution_Impl, const OFFSET: isize>() -> IQuerySolution_Vtbl { unsafe extern "system" fn GetQuery, Impl: IQuerySolution_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppquerynode: *mut *mut ::core::ffi::c_void, ppmaintype: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3055,17 +3039,13 @@ impl IRelationship_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IRichChunk_Impl: Sized { - fn GetData(&self, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetData(&self, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRichChunk {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IRichChunk_Vtbl { pub const fn new, Impl: IRichChunk_Impl, const OFFSET: isize>() -> IRichChunk_Vtbl { - unsafe extern "system" fn GetData, Impl: IRichChunk_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetData, Impl: IRichChunk_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetData(::core::mem::transmute_copy(&pfirstpos), ::core::mem::transmute_copy(&plength), ::core::mem::transmute_copy(&ppsz), ::core::mem::transmute_copy(&pvalue)).into() @@ -3466,15 +3446,15 @@ impl IRowsetCopyRows_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IRowsetCurrentIndex_Impl: Sized + IRowsetIndex_Impl { fn GetIndex(&self) -> ::windows_core::Result<*mut super::super::Storage::IndexServer::DBID>; fn SetIndex(&self, pindexid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IRowsetCurrentIndex {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IRowsetCurrentIndex_Vtbl { pub const fn new, Impl: IRowsetCurrentIndex_Impl, const OFFSET: isize>() -> IRowsetCurrentIndex_Vtbl { unsafe extern "system" fn GetIndex, Impl: IRowsetCurrentIndex_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppindexid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT { @@ -3503,35 +3483,31 @@ impl IRowsetCurrentIndex_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IRowsetEvents_Impl: Sized { - fn OnNewItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; - fn OnChangedItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; - fn OnDeletedItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; - fn OnRowsetEvent(&self, eventtype: ROWSETEVENT_TYPE, eventdata: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn OnNewItem(&self, itemid: *const ::windows_core::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; + fn OnChangedItem(&self, itemid: *const ::windows_core::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; + fn OnDeletedItem(&self, itemid: *const ::windows_core::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()>; + fn OnRowsetEvent(&self, eventtype: ROWSETEVENT_TYPE, eventdata: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRowsetEvents {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IRowsetEvents_Vtbl { pub const fn new, Impl: IRowsetEvents_Impl, const OFFSET: isize>() -> IRowsetEvents_Vtbl { - unsafe extern "system" fn OnNewItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnNewItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnNewItem(::core::mem::transmute_copy(&itemid), ::core::mem::transmute_copy(&newitemstate)).into() } - unsafe extern "system" fn OnChangedItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnChangedItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnChangedItem(::core::mem::transmute_copy(&itemid), ::core::mem::transmute_copy(&rowsetitemstate), ::core::mem::transmute_copy(&changeditemstate)).into() } - unsafe extern "system" fn OnDeletedItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnDeletedItem, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnDeletedItem(::core::mem::transmute_copy(&itemid), ::core::mem::transmute_copy(&deleteditemstate)).into() } - unsafe extern "system" fn OnRowsetEvent, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eventtype: ROWSETEVENT_TYPE, eventdata: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnRowsetEvent, Impl: IRowsetEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, eventtype: ROWSETEVENT_TYPE, eventdata: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnRowsetEvent(::core::mem::transmute_copy(&eventtype), ::core::mem::transmute_copy(&eventdata)).into() @@ -3626,16 +3602,16 @@ impl IRowsetIdentity_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IRowsetIndex_Impl: Sized { fn GetIndexInfo(&self, pckeycolumns: *mut usize, prgindexcolumndesc: *mut *mut DBINDEXCOLUMNDESC, pcindexpropertysets: *mut u32, prgindexpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; fn Seek(&self, haccessor: HACCESSOR, ckeyvalues: usize, pdata: *const ::core::ffi::c_void, dwseekoptions: u32) -> ::windows_core::Result<()>; fn SetRange(&self, haccessor: HACCESSOR, cstartkeycolumns: usize, pstartdata: *const ::core::ffi::c_void, cendkeycolumns: usize, penddata: *const ::core::ffi::c_void, dwrangeoptions: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IRowsetIndex {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IRowsetIndex_Vtbl { pub const fn new, Impl: IRowsetIndex_Impl, const OFFSET: isize>() -> IRowsetIndex_Vtbl { unsafe extern "system" fn GetIndexInfo, Impl: IRowsetIndex_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pckeycolumns: *mut usize, prgindexcolumndesc: *mut *mut DBINDEXCOLUMNDESC, pcindexpropertysets: *mut u32, prgindexpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -3664,16 +3640,16 @@ impl IRowsetIndex_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait IRowsetInfo_Impl: Sized { fn GetProperties(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; fn GetReferencedRowset(&self, iordinal: usize, riid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetSpecification(&self, riid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for IRowsetInfo {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl IRowsetInfo_Vtbl { pub const fn new, Impl: IRowsetInfo_Impl, const OFFSET: isize>() -> IRowsetInfo_Vtbl { unsafe extern "system" fn GetProperties, Impl: IRowsetInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -4241,14 +4217,10 @@ impl ISQLErrorInfo_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISQLGetDiagField_Impl: Sized { fn GetDiagField(&self, pdiaginfo: *mut KAGGETDIAG) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISQLGetDiagField {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISQLGetDiagField_Vtbl { pub const fn new, Impl: ISQLGetDiagField_Impl, const OFFSET: isize>() -> ISQLGetDiagField_Vtbl { unsafe extern "system" fn GetDiagField, Impl: ISQLGetDiagField_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdiaginfo: *mut KAGGETDIAG) -> ::windows_core::HRESULT { @@ -4428,17 +4400,17 @@ impl ISchemaProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub trait IScopedOperations_Impl: Sized + IBindResource_Impl { fn Copy(&self, crows: usize, rgpwszsourceurls: *const ::windows_core::PCWSTR, rgpwszdesturls: *const ::windows_core::PCWSTR, dwcopyflags: u32, pauthenticate: ::core::option::Option<&super::Com::IAuthenticate>, rgdwstatus: *mut u32, rgpwsznewurls: *mut ::windows_core::PWSTR, ppstringsbuffer: *mut *mut u16) -> ::windows_core::Result<()>; fn Move(&self, crows: usize, rgpwszsourceurls: *const ::windows_core::PCWSTR, rgpwszdesturls: *const ::windows_core::PCWSTR, dwmoveflags: u32, pauthenticate: ::core::option::Option<&super::Com::IAuthenticate>, rgdwstatus: *mut u32, rgpwsznewurls: *mut ::windows_core::PWSTR, ppstringsbuffer: *mut *mut u16) -> ::windows_core::Result<()>; fn Delete(&self, crows: usize, rgpwszurls: *const ::windows_core::PCWSTR, dwdeleteflags: u32, rgdwstatus: *mut u32) -> ::windows_core::Result<()>; fn OpenRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IScopedOperations {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl IScopedOperations_Vtbl { pub const fn new, Impl: IScopedOperations_Impl, const OFFSET: isize>() -> IScopedOperations_Vtbl { unsafe extern "system" fn Copy, Impl: IScopedOperations_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, crows: usize, rgpwszsourceurls: *const ::windows_core::PCWSTR, rgpwszdesturls: *const ::windows_core::PCWSTR, dwcopyflags: u32, pauthenticate: *mut ::core::ffi::c_void, rgdwstatus: *mut u32, rgpwsznewurls: *mut ::windows_core::PWSTR, ppstringsbuffer: *mut *mut u16) -> ::windows_core::HRESULT { @@ -4473,12 +4445,12 @@ impl IScopedOperations_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISearchCatalogManager_Impl: Sized { fn Name(&self) -> ::windows_core::Result<::windows_core::PWSTR>; - fn GetParameter(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT>; - fn SetParameter(&self, pszname: &::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetParameter(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT>; + fn SetParameter(&self, pszname: &::windows_core::PCWSTR, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetCatalogStatus(&self, pstatus: *mut CatalogStatus, ppausedreason: *mut CatalogPausedReason) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Reindex(&self) -> ::windows_core::Result<()>; @@ -4503,9 +4475,9 @@ pub trait ISearchCatalogManager_Impl: Sized { fn DiacriticSensitivity(&self) -> ::windows_core::Result; fn GetCrawlScopeManager(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISearchCatalogManager {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISearchCatalogManager_Vtbl { pub const fn new, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>() -> ISearchCatalogManager_Vtbl { unsafe extern "system" fn Name, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -4519,7 +4491,7 @@ impl ISearchCatalogManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetParameter, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameter, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut ::windows_core::PROPVARIANT) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParameter(::core::mem::transmute(&pszname)) { @@ -4530,7 +4502,7 @@ impl ISearchCatalogManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetParameter, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParameter, Impl: ISearchCatalogManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParameter(::core::mem::transmute(&pszname), ::core::mem::transmute_copy(&pvalue)).into() @@ -4750,14 +4722,14 @@ impl ISearchCatalogManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISearchCatalogManager2_Impl: Sized + ISearchCatalogManager_Impl { fn PrioritizeMatchingURLs(&self, pszpattern: &::windows_core::PCWSTR, dwprioritizeflags: PRIORITIZE_FLAGS) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISearchCatalogManager2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISearchCatalogManager2_Vtbl { pub const fn new, Impl: ISearchCatalogManager2_Impl, const OFFSET: isize>() -> ISearchCatalogManager2_Vtbl { unsafe extern "system" fn PrioritizeMatchingURLs, Impl: ISearchCatalogManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszpattern: ::windows_core::PCWSTR, dwprioritizeflags: PRIORITIZE_FLAGS) -> ::windows_core::HRESULT { @@ -5047,13 +5019,11 @@ impl ISearchLanguageSupport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait ISearchManager_Impl: Sized { fn GetIndexerVersionStr(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetIndexerVersion(&self, pdwmajor: *mut u32, pdwminor: *mut u32) -> ::windows_core::Result<()>; - fn GetParameter(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT>; - fn SetParameter(&self, pszname: &::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetParameter(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT>; + fn SetParameter(&self, pszname: &::windows_core::PCWSTR, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn ProxyName(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn BypassList(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn SetProxy(&self, suseproxy: PROXY_ACCESS, flocalbypassproxy: super::super::Foundation::BOOL, dwportnumber: u32, pszproxyname: &::windows_core::PCWSTR, pszbypasslist: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; @@ -5064,9 +5034,7 @@ pub trait ISearchManager_Impl: Sized { fn LocalBypass(&self) -> ::windows_core::Result; fn PortNumber(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISearchManager {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ISearchManager_Vtbl { pub const fn new, Impl: ISearchManager_Impl, const OFFSET: isize>() -> ISearchManager_Vtbl { unsafe extern "system" fn GetIndexerVersionStr, Impl: ISearchManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszversionstring: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -5085,7 +5053,7 @@ impl ISearchManager_Vtbl { let this = (*this).get_impl(); this.GetIndexerVersion(::core::mem::transmute_copy(&pdwmajor), ::core::mem::transmute_copy(&pdwminor)).into() } - unsafe extern "system" fn GetParameter, Impl: ISearchManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetParameter, Impl: ISearchManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut ::windows_core::PROPVARIANT) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetParameter(::core::mem::transmute(&pszname)) { @@ -5096,7 +5064,7 @@ impl ISearchManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetParameter, Impl: ISearchManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetParameter, Impl: ISearchManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetParameter(::core::mem::transmute(&pszname), ::core::mem::transmute_copy(&pvalue)).into() @@ -5209,15 +5177,11 @@ impl ISearchManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait ISearchManager2_Impl: Sized + ISearchManager_Impl { fn CreateCatalog(&self, pszcatalog: &::windows_core::PCWSTR) -> ::windows_core::Result; fn DeleteCatalog(&self, pszcatalog: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISearchManager2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ISearchManager2_Vtbl { pub const fn new, Impl: ISearchManager2_Impl, const OFFSET: isize>() -> ISearchManager2_Vtbl { unsafe extern "system" fn CreateCatalog, Impl: ISearchManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszcatalog: ::windows_core::PCWSTR, ppcatalogmanager: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5415,8 +5379,8 @@ impl ISearchProtocolThreadContext_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ISearchQueryHelper_Impl: Sized { fn ConnectionString(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn SetQueryContentLocale(&self, lcid: u32) -> ::windows_core::Result<()>; @@ -5440,9 +5404,9 @@ pub trait ISearchQueryHelper_Impl: Sized { fn SetQueryMaxResults(&self, cmaxresults: i32) -> ::windows_core::Result<()>; fn QueryMaxResults(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ISearchQueryHelper {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ISearchQueryHelper_Vtbl { pub const fn new, Impl: ISearchQueryHelper_Impl, const OFFSET: isize>() -> ISearchQueryHelper_Vtbl { unsafe extern "system" fn ConnectionString, Impl: ISearchQueryHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszconnectionstring: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -6069,15 +6033,15 @@ impl IService_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait ISessionProperties_Impl: Sized { fn GetProperties(&self, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; fn SetProperties(&self, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for ISessionProperties {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ISessionProperties_Vtbl { pub const fn new, Impl: ISessionProperties_Impl, const OFFSET: isize>() -> ISessionProperties_Vtbl { unsafe extern "system" fn GetProperties, Impl: ISessionProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT { @@ -6134,14 +6098,14 @@ impl ISimpleCommandCreator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] +#[cfg(feature = "Win32_Storage_IndexServer")] pub trait ISourcesRowset_Impl: Sized { fn GetSourcesRowset(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, riid: *const ::windows_core::GUID, cpropertysets: u32, rgproperties: *mut DBPROPSET, ppsourcesrowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::RuntimeName for ISourcesRowset {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ISourcesRowset_Vtbl { pub const fn new, Impl: ISourcesRowset_Impl, const OFFSET: isize>() -> ISourcesRowset_Vtbl { unsafe extern "system" fn GetSourcesRowset, Impl: ISourcesRowset_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, cpropertysets: u32, rgproperties: *mut DBPROPSET, ppsourcesrowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6189,20 +6153,16 @@ impl IStemmer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISubscriptionItem_Impl: Sized { fn GetCookie(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetSubscriptionItemInfo(&self, psubscriptioniteminfo: *mut SUBSCRIPTIONITEMINFO) -> ::windows_core::Result<()>; fn SetSubscriptionItemInfo(&self, psubscriptioniteminfo: *const SUBSCRIPTIONITEMINFO) -> ::windows_core::Result<()>; - fn ReadProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn WriteProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ReadProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn WriteProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EnumProperties(&self) -> ::windows_core::Result; fn NotifyChanged(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISubscriptionItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISubscriptionItem_Vtbl { pub const fn new, Impl: ISubscriptionItem_Impl, const OFFSET: isize>() -> ISubscriptionItem_Vtbl { unsafe extern "system" fn GetCookie, Impl: ISubscriptionItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcookie: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -6226,12 +6186,12 @@ impl ISubscriptionItem_Vtbl { let this = (*this).get_impl(); this.SetSubscriptionItemInfo(::core::mem::transmute_copy(&psubscriptioniteminfo)).into() } - unsafe extern "system" fn ReadProperties, Impl: ISubscriptionItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadProperties, Impl: ISubscriptionItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ReadProperties(::core::mem::transmute_copy(&ncount), ::core::mem::transmute_copy(&rgwszname), ::core::mem::transmute_copy(&rgvalue)).into() } - unsafe extern "system" fn WriteProperties, Impl: ISubscriptionItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn WriteProperties, Impl: ISubscriptionItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WriteProperties(::core::mem::transmute_copy(&ncount), ::core::mem::transmute_copy(&rgwszname), ::core::mem::transmute_copy(&rgvalue)).into() @@ -6422,14 +6382,14 @@ impl ISubscriptionMgr2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub trait ITableCreation_Impl: Sized + ITableDefinition_Impl { fn GetTableDefinition(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pccolumndescs: *mut usize, prgcolumndescs: *mut *mut DBCOLUMNDESC, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET, pcconstraintdescs: *mut u32, prgconstraintdescs: *mut *mut DBCONSTRAINTDESC, ppwszstringbuffer: *mut *mut u16) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ITableCreation {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ITableCreation_Vtbl { pub const fn new, Impl: ITableCreation_Impl, const OFFSET: isize>() -> ITableCreation_Vtbl { unsafe extern "system" fn GetTableDefinition, Impl: ITableCreation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pccolumndescs: *mut usize, prgcolumndescs: *mut *mut DBCOLUMNDESC, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET, pcconstraintdescs: *mut u32, prgconstraintdescs: *mut *mut DBCONSTRAINTDESC, ppwszstringbuffer: *mut *mut u16) -> ::windows_core::HRESULT { @@ -6443,17 +6403,17 @@ impl ITableCreation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub trait ITableDefinition_Impl: Sized { fn CreateTable(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, ptableid: *const super::super::Storage::IndexServer::DBID, ccolumndescs: usize, rgcolumndescs: *const DBCOLUMNDESC, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn DropTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; fn AddColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumndesc: *const DBCOLUMNDESC, ppcolumnid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; fn DropColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ITableDefinition {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ITableDefinition_Vtbl { pub const fn new, Impl: ITableDefinition_Impl, const OFFSET: isize>() -> ITableDefinition_Vtbl { unsafe extern "system" fn CreateTable, Impl: ITableDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, ccolumndescs: usize, rgcolumndescs: *const DBCOLUMNDESC, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6488,16 +6448,16 @@ impl ITableDefinition_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub trait ITableDefinitionWithConstraints_Impl: Sized + ITableCreation_Impl { fn AddConstraint(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintdesc: *const DBCONSTRAINTDESC) -> ::windows_core::Result<()>; fn CreateTableWithConstraints(&self, punkouter: ::core::option::Option<&::windows_core::IUnknown>, ptableid: *const super::super::Storage::IndexServer::DBID, ccolumndescs: usize, rgcolumndescs: *mut DBCOLUMNDESC, cconstraintdescs: u32, rgconstraintdescs: *const DBCONSTRAINTDESC, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn DropConstraint(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for ITableDefinitionWithConstraints {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ITableDefinitionWithConstraints_Vtbl { pub const fn new, Impl: ITableDefinitionWithConstraints_Impl, const OFFSET: isize>() -> ITableDefinitionWithConstraints_Vtbl { unsafe extern "system" fn AddConstraint, Impl: ITableDefinitionWithConstraints_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintdesc: *const DBCONSTRAINTDESC) -> ::windows_core::HRESULT { @@ -6686,8 +6646,8 @@ impl ITransactionObject_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`"] +#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub trait ITrusteeAdmin_Impl: Sized { fn CompareTrustees(&self, ptrustee1: *const super::super::Security::Authorization::TRUSTEE_W, ptrustee2: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::Result<()>; fn CreateTrustee(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; @@ -6695,9 +6655,9 @@ pub trait ITrusteeAdmin_Impl: Sized { fn SetTrusteeProperties(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::Result<()>; fn GetTrusteeProperties(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] impl ::windows_core::RuntimeName for ITrusteeAdmin {} -#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] impl ITrusteeAdmin_Vtbl { pub const fn new, Impl: ITrusteeAdmin_Impl, const OFFSET: isize>() -> ITrusteeAdmin_Vtbl { unsafe extern "system" fn CompareTrustees, Impl: ITrusteeAdmin_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptrustee1: *const super::super::Security::Authorization::TRUSTEE_W, ptrustee2: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::HRESULT { @@ -6868,10 +6828,10 @@ impl IUMSInitialize_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub trait IUrlAccessor_Impl: Sized { - fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetDocFormat(&self, wszdocformat: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::Result<()>; fn GetCLSID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetHost(&self, wszhost: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::Result<()>; @@ -6885,12 +6845,12 @@ pub trait IUrlAccessor_Impl: Sized { fn BindToStream(&self) -> ::windows_core::Result; fn BindToFilter(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::RuntimeName for IUrlAccessor {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl IUrlAccessor_Vtbl { pub const fn new, Impl: IUrlAccessor_Impl, const OFFSET: isize>() -> IUrlAccessor_Vtbl { - unsafe extern "system" fn AddRequestParameter, Impl: IUrlAccessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddRequestParameter, Impl: IUrlAccessor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddRequestParameter(::core::mem::transmute_copy(&pspec), ::core::mem::transmute_copy(&pvar)).into() @@ -7012,16 +6972,16 @@ impl IUrlAccessor_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub trait IUrlAccessor2_Impl: Sized + IUrlAccessor_Impl { fn GetDisplayUrl(&self, wszdocurl: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::Result<()>; fn IsDocument(&self) -> ::windows_core::Result<()>; fn GetCodePage(&self, wszcodepage: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::RuntimeName for IUrlAccessor2 {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl IUrlAccessor2_Vtbl { pub const fn new, Impl: IUrlAccessor2_Impl, const OFFSET: isize>() -> IUrlAccessor2_Vtbl { unsafe extern "system" fn GetDisplayUrl, Impl: IUrlAccessor2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszdocurl: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::HRESULT { @@ -7050,14 +7010,14 @@ impl IUrlAccessor2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub trait IUrlAccessor3_Impl: Sized + IUrlAccessor2_Impl { fn GetImpersonationSidBlobs(&self, pcwszurl: &::windows_core::PCWSTR, pcsidcount: *mut u32, ppsidblobs: *mut *mut super::Com::BLOB) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::RuntimeName for IUrlAccessor3 {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl IUrlAccessor3_Vtbl { pub const fn new, Impl: IUrlAccessor3_Impl, const OFFSET: isize>() -> IUrlAccessor3_Vtbl { unsafe extern "system" fn GetImpersonationSidBlobs, Impl: IUrlAccessor3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcwszurl: ::windows_core::PCWSTR, pcsidcount: *mut u32, ppsidblobs: *mut *mut super::Com::BLOB) -> ::windows_core::HRESULT { @@ -7071,15 +7031,15 @@ impl IUrlAccessor3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IUrlAccessor4_Impl: Sized + IUrlAccessor3_Impl { fn ShouldIndexItemContent(&self) -> ::windows_core::Result; fn ShouldIndexProperty(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IUrlAccessor4 {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IUrlAccessor4_Vtbl { pub const fn new, Impl: IUrlAccessor4_Impl, const OFFSET: isize>() -> IUrlAccessor4_Vtbl { unsafe extern "system" fn ShouldIndexItemContent, Impl: IUrlAccessor4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfindexcontent: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -7375,27 +7335,23 @@ impl IWordSink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait OLEDBSimpleProvider_Impl: Sized { fn getRowCount(&self) -> ::windows_core::Result; fn getColumnCount(&self) -> ::windows_core::Result; fn getRWStatus(&self, irow: isize, icolumn: isize) -> ::windows_core::Result; - fn getVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT) -> ::windows_core::Result; - fn setVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT, var: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn getLocale(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn deleteRows(&self, irow: isize, crows: isize) -> ::windows_core::Result; fn insertRows(&self, irow: isize, crows: isize) -> ::windows_core::Result; - fn find(&self, irowstart: isize, icolumn: isize, val: &super::Variant::VARIANT, findflags: OSPFIND, comptype: OSPCOMP) -> ::windows_core::Result; + fn find(&self, irowstart: isize, icolumn: isize, val: &::windows_core::VARIANT, findflags: OSPFIND, comptype: OSPCOMP) -> ::windows_core::Result; fn addOLEDBSimpleProviderListener(&self, pospilistener: ::core::option::Option<&OLEDBSimpleProviderListener>) -> ::windows_core::Result<()>; fn removeOLEDBSimpleProviderListener(&self, pospilistener: ::core::option::Option<&OLEDBSimpleProviderListener>) -> ::windows_core::Result<()>; fn isAsync(&self) -> ::windows_core::Result; fn getEstimatedRows(&self) -> ::windows_core::Result; fn stopTransfer(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for OLEDBSimpleProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl OLEDBSimpleProvider_Vtbl { pub const fn new, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>() -> OLEDBSimpleProvider_Vtbl { unsafe extern "system" fn getRowCount, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcrows: *mut isize) -> ::windows_core::HRESULT { @@ -7431,7 +7387,7 @@ impl OLEDBSimpleProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getVariant, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, pvar: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getVariant, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getVariant(::core::mem::transmute_copy(&irow), ::core::mem::transmute_copy(&icolumn), ::core::mem::transmute_copy(&format)) { @@ -7442,7 +7398,7 @@ impl OLEDBSimpleProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setVariant, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, var: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setVariant, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setVariant(::core::mem::transmute_copy(&irow), ::core::mem::transmute_copy(&icolumn), ::core::mem::transmute_copy(&format), ::core::mem::transmute(&var)).into() @@ -7480,7 +7436,7 @@ impl OLEDBSimpleProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn find, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irowstart: isize, icolumn: isize, val: super::Variant::VARIANT, findflags: OSPFIND, comptype: OSPCOMP, pirowfound: *mut isize) -> ::windows_core::HRESULT { + unsafe extern "system" fn find, Impl: OLEDBSimpleProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, irowstart: isize, icolumn: isize, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, findflags: OSPFIND, comptype: OSPCOMP, pirowfound: *mut isize) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.find(::core::mem::transmute_copy(&irowstart), ::core::mem::transmute_copy(&icolumn), ::core::mem::transmute(&val), ::core::mem::transmute_copy(&findflags), ::core::mem::transmute_copy(&comptype)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/Search/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Search/mod.rs index 09a4a0d34f..a7e5593427 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Search/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Search/mod.rs @@ -1751,8 +1751,8 @@ pub struct IAccessor_Vtbl { ::windows_core::imp::com_interface!(IAlterIndex, IAlterIndex_Vtbl, 0x0c733aa6_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IAlterIndex, ::windows_core::IUnknown); impl IAlterIndex { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn AlterIndex(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, pnewindexid: *const super::super::Storage::IndexServer::DBID, rgpropertysets: &mut [DBPROPSET]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AlterIndex)(::windows_core::Interface::as_raw(self), ptableid, pindexid, pnewindexid, rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr())).ok() } @@ -1761,21 +1761,21 @@ impl IAlterIndex { #[doc(hidden)] pub struct IAlterIndex_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub AlterIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, pnewindexid: *const super::super::Storage::IndexServer::DBID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] AlterIndex: usize, } ::windows_core::imp::com_interface!(IAlterTable, IAlterTable_Vtbl, 0x0c733aa5_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IAlterTable, ::windows_core::IUnknown); impl IAlterTable { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn AlterColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID, dwcolumndescflags: u32, pcolumndesc: *const DBCOLUMNDESC) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AlterColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumnid, dwcolumndescflags, pcolumndesc).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn AlterTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pnewtableid: *const super::super::Storage::IndexServer::DBID, rgpropertysets: &mut [DBPROPSET]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AlterTable)(::windows_core::Interface::as_raw(self), ptableid, pnewtableid, rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr())).ok() } @@ -1784,13 +1784,13 @@ impl IAlterTable { #[doc(hidden)] pub struct IAlterTable_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub AlterColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID, dwcolumndescflags: u32, pcolumndesc: *const DBCOLUMNDESC) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com")))] AlterColumn: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub AlterTable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pnewtableid: *const super::super::Storage::IndexServer::DBID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] AlterTable: usize, } ::windows_core::imp::com_interface!(IBindResource, IBindResource_Vtbl, 0x0c733ab1_2a1c_11ce_ade5_00aa0044773d); @@ -1957,8 +1957,8 @@ impl IColumnsRowset { pub unsafe fn GetAvailableColumns(&self, pcoptcolumns: *mut usize, prgoptcolumns: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetAvailableColumns)(::windows_core::Interface::as_raw(self), pcoptcolumns, prgoptcolumns).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetColumnsRowset(&self, punkouter: P0, rgoptcolumns: &[super::super::Storage::IndexServer::DBID], riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, ppcolrowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -1974,9 +1974,9 @@ pub struct IColumnsRowset_Vtbl { pub GetAvailableColumns: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcoptcolumns: *mut usize, prgoptcolumns: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetAvailableColumns: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetColumnsRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, coptcolumns: usize, rgoptcolumns: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, ppcolrowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetColumnsRowset: usize, } ::windows_core::imp::com_interface!(ICommand, ICommand_Vtbl, 0x0c733a63_2a1c_11ce_ade5_00aa0044773d); @@ -2121,13 +2121,13 @@ pub struct ICommandPrepare_Vtbl { ::windows_core::imp::com_interface!(ICommandProperties, ICommandProperties_Vtbl, 0x0c733a79_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ICommandProperties, ::windows_core::IUnknown); impl ICommandProperties { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertysets, prgpropertysets).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn SetProperties(&self, rgpropertysets: &[DBPROPSET]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetProperties)(::windows_core::Interface::as_raw(self), rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr())).ok() } @@ -2136,13 +2136,13 @@ impl ICommandProperties { #[doc(hidden)] pub struct ICommandProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetProperties: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub SetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *const DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] SetProperties: usize, } ::windows_core::imp::com_interface!(ICommandStream, ICommandStream_Vtbl, 0x0c733abf_2a1c_11ce_ade5_00aa0044773d); @@ -2299,9 +2299,9 @@ impl ICondition { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).GetSubConditions)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub unsafe fn GetComparisonInfo(&self, ppszpropertyname: ::core::option::Option<*mut ::windows_core::PWSTR>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut super::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_System_Search_Common\"`"] + #[cfg(feature = "Win32_System_Search_Common")] + pub unsafe fn GetComparisonInfo(&self, ppszpropertyname: ::core::option::Option<*mut ::windows_core::PWSTR>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetComparisonInfo)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppszpropertyname.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pcop.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppropvar.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetValueType(&self) -> ::windows_core::Result<::windows_core::PWSTR> { @@ -2332,9 +2332,9 @@ pub struct ICondition_Vtbl { #[cfg(not(feature = "Win32_System_Search_Common"))] GetConditionType: usize, pub GetSubConditions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub GetComparisonInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Search_Common")] + pub GetComparisonInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszpropertyname: *mut ::windows_core::PWSTR, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Search_Common"))] GetComparisonInfo: usize, pub GetValueType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszvaluetypename: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GetValueNormalization: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppsznormalization: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, @@ -2402,9 +2402,9 @@ impl ICondition2 { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetSubConditions)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub unsafe fn GetComparisonInfo(&self, ppszpropertyname: ::core::option::Option<*mut ::windows_core::PWSTR>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut super::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_System_Search_Common\"`"] + #[cfg(feature = "Win32_System_Search_Common")] + pub unsafe fn GetComparisonInfo(&self, ppszpropertyname: ::core::option::Option<*mut ::windows_core::PWSTR>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetComparisonInfo)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppszpropertyname.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pcop.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppropvar.unwrap_or(::std::ptr::null_mut()))).ok() } pub unsafe fn GetValueType(&self) -> ::windows_core::Result<::windows_core::PWSTR> { @@ -2428,9 +2428,9 @@ impl ICondition2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetLocale)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetLeafConditionInfo(&self, ppropkey: ::core::option::Option<*mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut super::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_System_Search_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn GetLeafConditionInfo(&self, ppropkey: ::core::option::Option<*mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY>, pcop: ::core::option::Option<*mut Common::CONDITION_OPERATION>, ppropvar: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetLeafConditionInfo)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropkey.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pcop.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppropvar.unwrap_or(::std::ptr::null_mut()))).ok() } } @@ -2440,9 +2440,9 @@ impl ICondition2 { pub struct ICondition2_Vtbl { pub base__: ICondition_Vtbl, pub GetLocale: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszlocalename: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetLeafConditionInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub GetLeafConditionInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pcop: *mut Common::CONDITION_OPERATION, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] GetLeafConditionInfo: usize, } ::windows_core::imp::com_interface!(IConditionFactory, IConditionFactory_Vtbl, 0xa5efe073_b16f_474f_9f3e_9f8b497a3e08); @@ -2468,9 +2468,9 @@ impl IConditionFactory { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MakeAndOr)(::windows_core::Interface::as_raw(self), ct, peusubs.into_param().abi(), fsimplify.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] + pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const ::windows_core::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -2480,7 +2480,7 @@ impl IConditionFactory { P5: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ppropvar, ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ::core::mem::transmute(ppropvar), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2504,9 +2504,9 @@ pub struct IConditionFactory_Vtbl { pub MakeAndOr: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ct: Common::CONDITION_TYPE, peusubs: *mut ::core::ffi::c_void, fsimplify: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common")))] MakeAndOr: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub MakeLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropertyname: ::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, fexpand: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant")))] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] + pub MakeLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpropertyname: ::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, fexpand: super::super::Foundation::BOOL, ppcresult: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common")))] MakeLeaf: usize, #[cfg(feature = "Win32_System_Com")] pub Resolve: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pc: *mut ::core::ffi::c_void, sqro: STRUCTURED_QUERY_RESOLVE_OPTION, pstreferencetime: *const super::super::Foundation::SYSTEMTIME, ppcresolved: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2536,9 +2536,9 @@ impl IConditionFactory2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MakeAndOr)(::windows_core::Interface::as_raw(self), ct, peusubs.into_param().abi(), fsimplify.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] + pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const ::windows_core::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -2548,7 +2548,7 @@ impl IConditionFactory2 { P5: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ppropvar, ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ::core::mem::transmute(ppropvar), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2626,9 +2626,9 @@ impl IConditionFactory2 { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).CreateBooleanLeaf)(::windows_core::Interface::as_raw(self), propkey, cop, fvalue.into_param().abi(), cco, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn CreateLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const super::Com::StructuredStorage::PROPVARIANT, pszsemantictype: P0, pszlocalename: P1, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, cco: CONDITION_CREATION_OPTIONS) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Search_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn CreateLeaf(&self, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const ::windows_core::PROPVARIANT, pszsemantictype: P0, pszlocalename: P1, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, cco: CONDITION_CREATION_OPTIONS) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -2638,7 +2638,7 @@ impl IConditionFactory2 { T: ::windows_core::Interface, { let mut result__ = ::std::ptr::null_mut(); - (::windows_core::Interface::vtable(self).CreateLeaf)(::windows_core::Interface::as_raw(self), propkey, cop, propvar, pszsemantictype.into_param().abi(), pszlocalename.into_param().abi(), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), cco, &T::IID, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateLeaf)(::windows_core::Interface::as_raw(self), propkey, cop, ::core::mem::transmute(propvar), pszsemantictype.into_param().abi(), pszlocalename.into_param().abi(), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), cco, &T::IID, &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -2680,9 +2680,9 @@ pub struct IConditionFactory2_Vtbl { pub CreateBooleanLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, fvalue: super::super::Foundation::BOOL, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] CreateBooleanLeaf: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub CreateLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const super::Com::StructuredStorage::PROPVARIANT, pszsemantictype: ::windows_core::PCWSTR, pszlocalename: ::windows_core::PCWSTR, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub CreateLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propkey: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, cop: Common::CONDITION_OPERATION, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pszsemantictype: ::windows_core::PCWSTR, pszlocalename: ::windows_core::PCWSTR, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, cco: CONDITION_CREATION_OPTIONS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_System_Search_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] CreateLeaf: usize, #[cfg(feature = "Win32_System_Com")] pub ResolveCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pc: *mut ::core::ffi::c_void, sqro: STRUCTURED_QUERY_RESOLVE_OPTION, pstreferencetime: *const super::super::Foundation::SYSTEMTIME, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2722,14 +2722,12 @@ impl IConditionGenerator { { (::windows_core::Interface::vtable(self).GenerateForLeaf)(::windows_core::Interface::as_raw(self), pconditionfactory.into_param().abi(), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), pszvalue.into_param().abi(), pszvalue2.into_param().abi(), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), automaticwildcard.into_param().abi(), pnostringquery, ::core::mem::transmute(ppqueryexpression)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn DefaultPhrase(&self, pszvaluetype: P0, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, fuseenglish: P1, ppszphrase: ::core::option::Option<*mut ::windows_core::PWSTR>) -> ::windows_core::Result<()> + pub unsafe fn DefaultPhrase(&self, pszvaluetype: P0, ppropvar: *const ::windows_core::PROPVARIANT, fuseenglish: P1, ppszphrase: ::core::option::Option<*mut ::windows_core::PWSTR>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).DefaultPhrase)(::windows_core::Interface::as_raw(self), pszvaluetype.into_param().abi(), ppropvar, fuseenglish.into_param().abi(), ::core::mem::transmute(ppszphrase.unwrap_or(::std::ptr::null_mut()))).ok() + (::windows_core::Interface::vtable(self).DefaultPhrase)(::windows_core::Interface::as_raw(self), pszvaluetype.into_param().abi(), ::core::mem::transmute(ppropvar), fuseenglish.into_param().abi(), ::core::mem::transmute(ppszphrase.unwrap_or(::std::ptr::null_mut()))).ok() } } #[repr(C)] @@ -2742,10 +2740,7 @@ pub struct IConditionGenerator_Vtbl { pub GenerateForLeaf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pconditionfactory: *mut ::core::ffi::c_void, pszpropertyname: ::windows_core::PCWSTR, cop: Common::CONDITION_OPERATION, pszvaluetype: ::windows_core::PCWSTR, pszvalue: ::windows_core::PCWSTR, pszvalue2: ::windows_core::PCWSTR, ppropertynameterm: *mut ::core::ffi::c_void, poperationterm: *mut ::core::ffi::c_void, pvalueterm: *mut ::core::ffi::c_void, automaticwildcard: super::super::Foundation::BOOL, pnostringquery: *mut super::super::Foundation::BOOL, ppqueryexpression: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common")))] GenerateForLeaf: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub DefaultPhrase: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - DefaultPhrase: usize, + pub DefaultPhrase: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszvaluetype: ::windows_core::PCWSTR, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, fuseenglish: super::super::Foundation::BOOL, ppszphrase: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IConvertType, IConvertType_Vtbl, 0x0c733a88_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IConvertType, ::windows_core::IUnknown); @@ -2830,18 +2825,18 @@ pub struct IDBAsynchStatus_Vtbl { ::windows_core::imp::com_interface!(IDBBinderProperties, IDBBinderProperties_Vtbl, 0x0c733ab3_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDBBinderProperties, ::windows_core::IUnknown, IDBProperties); impl IDBBinderProperties { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertysets, prgpropertysets).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] pub unsafe fn GetPropertyInfo(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: ::core::option::Option<*mut *mut u16>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetPropertyInfo)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertyinfosets, prgpropertyinfosets, ::core::mem::transmute(ppdescbuffer.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn SetProperties(&self, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetProperties)(::windows_core::Interface::as_raw(self), rgpropertysets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertysets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr()))).ok() } @@ -2892,8 +2887,8 @@ pub struct IDBCreateSession_Vtbl { ::windows_core::imp::com_interface!(IDBDataSourceAdmin, IDBDataSourceAdmin_Vtbl, 0x0c733a7a_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDBDataSourceAdmin, ::windows_core::IUnknown); impl IDBDataSourceAdmin { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn CreateDataSource(&self, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, punkouter: P0, riid: *const ::windows_core::GUID, ppdbsession: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -2903,13 +2898,13 @@ impl IDBDataSourceAdmin { pub unsafe fn DestroyDataSource(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DestroyDataSource)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] pub unsafe fn GetCreationProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: ::core::option::Option<*mut *mut u16>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCreationProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertyinfosets, prgpropertyinfosets, ::core::mem::transmute(ppdescbuffer.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn ModifyDataSource(&self, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ModifyDataSource)(::windows_core::Interface::as_raw(self), rgpropertysets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertysets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr()))).ok() } @@ -2918,18 +2913,18 @@ impl IDBDataSourceAdmin { #[doc(hidden)] pub struct IDBDataSourceAdmin_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub CreateDataSource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, punkouter: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppdbsession: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] CreateDataSource: usize, pub DestroyDataSource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Variant")] pub GetCreationProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: *mut *mut u16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Variant"))] GetCreationProperties: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub ModifyDataSource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] ModifyDataSource: usize, } ::windows_core::imp::com_interface!(IDBInfo, IDBInfo_Vtbl, 0x0c733a89_2a1c_11ce_ade5_00aa0044773d); @@ -2998,18 +2993,18 @@ pub struct IDBPromptInitialize_Vtbl { ::windows_core::imp::com_interface!(IDBProperties, IDBProperties_Vtbl, 0x0c733a8a_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDBProperties, ::windows_core::IUnknown); impl IDBProperties { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertysets, prgpropertysets).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Variant\"`"] + #[cfg(feature = "Win32_System_Variant")] pub unsafe fn GetPropertyInfo(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: ::core::option::Option<*mut *mut u16>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetPropertyInfo)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertyinfosets, prgpropertyinfosets, ::core::mem::transmute(ppdescbuffer.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn SetProperties(&self, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetProperties)(::windows_core::Interface::as_raw(self), rgpropertysets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertysets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr()))).ok() } @@ -3018,17 +3013,17 @@ impl IDBProperties { #[doc(hidden)] pub struct IDBProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Variant")] pub GetPropertyInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertyinfosets: *mut u32, prgpropertyinfosets: *mut *mut DBPROPINFOSET, ppdescbuffer: *mut *mut u16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Variant"))] GetPropertyInfo: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub SetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] SetProperties: usize, } ::windows_core::imp::com_interface!(IDBSchemaCommand, IDBSchemaCommand_Vtbl, 0x0c733a50_2a1c_11ce_ade5_00aa0044773d); @@ -3055,9 +3050,9 @@ pub struct IDBSchemaCommand_Vtbl { ::windows_core::imp::com_interface!(IDBSchemaRowset, IDBSchemaRowset_Vtbl, 0x0c733a7b_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDBSchemaRowset, ::windows_core::IUnknown); impl IDBSchemaRowset { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRowset(&self, punkouter: P0, rguidschema: *const ::windows_core::GUID, rgrestrictions: ::core::option::Option<&[super::Variant::VARIANT]>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] + pub unsafe fn GetRowset(&self, punkouter: P0, rguidschema: *const ::windows_core::GUID, rgrestrictions: ::core::option::Option<&[::windows_core::VARIANT]>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, { @@ -3082,22 +3077,18 @@ impl IDBSchemaRowset { #[doc(hidden)] pub struct IDBSchemaRowset_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const super::Variant::VARIANT, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_Storage_IndexServer")] + pub GetRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, rguidschema: *const ::windows_core::GUID, crestrictions: u32, rgrestrictions: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetRowset: usize, pub GetSchemas: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcschemas: *mut u32, prgschemas: *mut *mut ::windows_core::GUID, prgrestrictionsupport: *mut *mut u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDCInfo, IDCInfo_Vtbl, 0x0c733a9c_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDCInfo, ::windows_core::IUnknown); impl IDCInfo { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetInfo(&self, cinfo: u32, rgeinfotype: *const u32, prginfo: *mut *mut DCINFO) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetInfo)(::windows_core::Interface::as_raw(self), cinfo, rgeinfotype, prginfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn SetInfo(&self, rginfo: &[DCINFO]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetInfo)(::windows_core::Interface::as_raw(self), rginfo.len().try_into().unwrap(), ::core::mem::transmute(rginfo.as_ptr())).ok() } @@ -3106,14 +3097,8 @@ impl IDCInfo { #[doc(hidden)] pub struct IDCInfo_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cinfo: u32, rgeinfotype: *const u32, prginfo: *mut *mut DCINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub SetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cinfo: u32, rginfo: *const DCINFO) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetInfo: usize, } ::windows_core::imp::com_interface!(IDataConvert, IDataConvert_Vtbl, 0x0c733a8d_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IDataConvert, ::windows_core::IUnknown); @@ -3313,8 +3298,6 @@ pub struct IEntity_Vtbl { ::windows_core::imp::com_interface!(IEnumItemProperties, IEnumItemProperties_Vtbl, 0xf72c8d96_6dbd_11d1_a1e8_00c04fc2fbe1); ::windows_core::imp::interface_hierarchy!(IEnumItemProperties, ::windows_core::IUnknown); impl IEnumItemProperties { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn Next(&self, rgelt: &mut [ITEMPROP], pceltfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgelt.len().try_into().unwrap(), ::core::mem::transmute(rgelt.as_ptr()), pceltfetched).ok() } @@ -3337,10 +3320,7 @@ impl IEnumItemProperties { #[doc(hidden)] pub struct IEnumItemProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32, rgelt: *mut ITEMPROP, pceltfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, celt: u32) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3432,8 +3412,8 @@ pub struct IEnumSubscription_Vtbl { ::windows_core::imp::com_interface!(IErrorLookup, IErrorLookup_Vtbl, 0x0c733a66_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IErrorLookup, ::windows_core::IUnknown); impl IErrorLookup { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] pub unsafe fn GetErrorDescription(&self, hrerror: ::windows_core::HRESULT, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, lcid: u32, pbstrsource: ::core::option::Option<*mut ::windows_core::BSTR>, pbstrdescription: ::core::option::Option<*mut ::windows_core::BSTR>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetErrorDescription)(::windows_core::Interface::as_raw(self), hrerror, dwlookupid, pdispparams, lcid, ::core::mem::transmute(pbstrsource.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pbstrdescription.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -3448,9 +3428,9 @@ impl IErrorLookup { #[doc(hidden)] pub struct IErrorLookup_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com")] pub GetErrorDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrerror: ::windows_core::HRESULT, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, lcid: u32, pbstrsource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com"))] GetErrorDescription: usize, pub GetHelpInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hrerror: ::windows_core::HRESULT, dwlookupid: u32, lcid: u32, pbstrhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwhelpcontext: *mut u32) -> ::windows_core::HRESULT, pub ReleaseErrors: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwdynamicerrorid: u32) -> ::windows_core::HRESULT, @@ -3458,8 +3438,8 @@ pub struct IErrorLookup_Vtbl { ::windows_core::imp::com_interface!(IErrorRecords, IErrorRecords_Vtbl, 0x0c733a67_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IErrorRecords, ::windows_core::IUnknown); impl IErrorRecords { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] pub unsafe fn AddErrorRecord(&self, perrorinfo: *const ERRORINFO, dwlookupid: u32, pdispparams: ::core::option::Option<*const super::Com::DISPPARAMS>, punkcustomerror: P0, dwdynamicerrorid: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -3479,8 +3459,8 @@ impl IErrorRecords { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetErrorInfo)(::windows_core::Interface::as_raw(self), ulrecordnum, lcid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] pub unsafe fn GetErrorParameters(&self, ulrecordnum: u32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetErrorParameters)(::windows_core::Interface::as_raw(self), ulrecordnum, &mut result__).from_abi(result__) @@ -3494,9 +3474,9 @@ impl IErrorRecords { #[doc(hidden)] pub struct IErrorRecords_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com")] pub AddErrorRecord: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, perrorinfo: *const ERRORINFO, dwlookupid: u32, pdispparams: *const super::Com::DISPPARAMS, punkcustomerror: *mut ::core::ffi::c_void, dwdynamicerrorid: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com"))] AddErrorRecord: usize, pub GetBasicErrorInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulrecordnum: u32, perrorinfo: *mut ERRORINFO) -> ::windows_core::HRESULT, pub GetCustomErrorObject: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulrecordnum: u32, riid: *const ::windows_core::GUID, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3504,9 +3484,9 @@ pub struct IErrorRecords_Vtbl { pub GetErrorInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulrecordnum: u32, lcid: u32, pperrorinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetErrorInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com")] pub GetErrorParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulrecordnum: u32, pdispparams: *mut super::Com::DISPPARAMS) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com"))] GetErrorParameters: usize, pub GetRecordCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcrecords: *mut u32) -> ::windows_core::HRESULT, } @@ -3577,8 +3557,8 @@ pub struct IGetSourceRow_Vtbl { ::windows_core::imp::com_interface!(IIndexDefinition, IIndexDefinition_Vtbl, 0x0c733a68_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IIndexDefinition, ::windows_core::IUnknown); impl IIndexDefinition { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn CreateIndex(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, rgindexcolumndescs: &[DBINDEXCOLUMNDESC], rgpropertysets: &mut [DBPROPSET], ppindexid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).CreateIndex)(::windows_core::Interface::as_raw(self), ptableid, ::core::mem::transmute(pindexid.unwrap_or(::std::ptr::null())), rgindexcolumndescs.len().try_into().unwrap(), ::core::mem::transmute(rgindexcolumndescs.as_ptr()), rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr()), ::core::mem::transmute(ppindexid.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -3592,9 +3572,9 @@ impl IIndexDefinition { #[doc(hidden)] pub struct IIndexDefinition_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub CreateIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, cindexcolumndescs: usize, rgindexcolumndescs: *const DBINDEXCOLUMNDESC, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, ppindexid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] CreateIndex: usize, #[cfg(feature = "Win32_Storage_IndexServer")] pub DropIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, @@ -3604,20 +3584,15 @@ pub struct IIndexDefinition_Vtbl { ::windows_core::imp::com_interface!(IInterval, IInterval_Vtbl, 0x6bf0a714_3c18_430b_8b5d_83b1c234d3db); ::windows_core::imp::interface_hierarchy!(IInterval, ::windows_core::IUnknown); impl IInterval { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetLimits(&self, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut super::Com::StructuredStorage::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetLimits)(::windows_core::Interface::as_raw(self), pilklower, ppropvarlower, pilkupper, ppropvarupper).ok() + pub unsafe fn GetLimits(&self, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut ::windows_core::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetLimits)(::windows_core::Interface::as_raw(self), pilklower, ::core::mem::transmute(ppropvarlower), pilkupper, ::core::mem::transmute(ppropvarupper)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IInterval_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetLimits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut super::Com::StructuredStorage::PROPVARIANT, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetLimits: usize, + pub GetLimits: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pilklower: *mut INTERVAL_LIMIT_KIND, ppropvarlower: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pilkupper: *mut INTERVAL_LIMIT_KIND, ppropvarupper: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ILoadFilter, ILoadFilter_Vtbl, 0xc7310722_ac80_11d1_8df3_00c04fb6ef4f); ::windows_core::imp::interface_hierarchy!(ILoadFilter, ::windows_core::IUnknown); @@ -3732,8 +3707,8 @@ impl IMDDataset { pub unsafe fn GetAxisInfo(&self, pcaxes: *mut usize, prgaxisinfo: *mut *mut MDAXISINFO) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetAxisInfo)(::windows_core::Interface::as_raw(self), pcaxes, prgaxisinfo).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetAxisRowset(&self, punkouter: P0, iaxis: usize, riid: *const ::windows_core::GUID, rgpropertysets: &mut [DBPROPSET], pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -3757,9 +3732,9 @@ pub struct IMDDataset_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub FreeAxisInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, caxes: usize, rgaxisinfo: *const MDAXISINFO) -> ::windows_core::HRESULT, pub GetAxisInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcaxes: *mut usize, prgaxisinfo: *mut *mut MDAXISINFO) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetAxisRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, iaxis: usize, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetAxisRowset: usize, pub GetCellData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, haccessor: HACCESSOR, ulstartcell: usize, ulendcell: usize, pdata: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetSpecification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppspecification: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3786,8 +3761,8 @@ pub struct IMDFind_Vtbl { ::windows_core::imp::com_interface!(IMDRangeRowset, IMDRangeRowset_Vtbl, 0x0c733aa0_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IMDRangeRowset, ::windows_core::IUnknown); impl IMDRangeRowset { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetRangeRowset(&self, punkouter: P0, ulstartcell: usize, ulendcell: usize, riid: *const ::windows_core::GUID, rgpropertysets: &mut [DBPROPSET], pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -3799,9 +3774,9 @@ impl IMDRangeRowset { #[doc(hidden)] pub struct IMDRangeRowset_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetRangeRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ulstartcell: usize, ulendcell: usize, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetRangeRowset: usize, } ::windows_core::imp::com_interface!(IMetaData, IMetaData_Vtbl, 0x780102b0_c43b_4876_bc7b_5e9ba5c88794); @@ -3951,8 +3926,8 @@ pub struct IOpLockStatus_Vtbl { ::windows_core::imp::com_interface!(IOpenRowset, IOpenRowset_Vtbl, 0x0c733a69_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IOpenRowset, ::windows_core::IUnknown); impl IOpenRowset { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn OpenRowset(&self, punkouter: P0, ptableid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, pindexid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pprowset: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -3964,9 +3939,9 @@ impl IOpenRowset { #[doc(hidden)] pub struct IOpenRowset_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub OpenRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] OpenRowset: usize, } ::windows_core::imp::com_interface!(IParentRowset, IParentRowset_Vtbl, 0x0c733aaa_2a1c_11ce_ade5_00aa0044773d); @@ -4041,24 +4016,18 @@ impl IQueryParser { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Parse)(::windows_core::Interface::as_raw(self), pszinputstring.into_param().abi(), pcustomproperties.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), option, poptionvalue).ok() + pub unsafe fn SetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), option, ::core::mem::transmute(poptionvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION) -> ::windows_core::Result { + pub unsafe fn GetOption(&self, option: STRUCTURED_QUERY_SINGLE_OPTION) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetOption)(::windows_core::Interface::as_raw(self), option, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetMultiOption(&self, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: P0, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetMultiOption(&self, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: P0, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetMultiOption)(::windows_core::Interface::as_raw(self), option, pszoptionkey.into_param().abi(), poptionvalue).ok() + (::windows_core::Interface::vtable(self).SetMultiOption)(::windows_core::Interface::as_raw(self), option, pszoptionkey.into_param().abi(), ::core::mem::transmute(poptionvalue)).ok() } pub unsafe fn GetSchemaProvider(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4100,18 +4069,9 @@ pub struct IQueryParser_Vtbl { pub Parse: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszinputstring: ::windows_core::PCWSTR, pcustomproperties: *mut ::core::ffi::c_void, ppsolution: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Parse: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetOption: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetOption: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetMultiOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: ::windows_core::PCWSTR, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetMultiOption: usize, + pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_SINGLE_OPTION, poptionvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetMultiOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: STRUCTURED_QUERY_MULTIOPTION, pszoptionkey: ::windows_core::PCWSTR, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetSchemaProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppschemaprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub RestateToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcondition: *mut ::core::ffi::c_void, fuseenglish: super::super::Foundation::BOOL, ppszquerystring: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, @@ -4142,10 +4102,8 @@ impl IQueryParserManager { { (::windows_core::Interface::vtable(self).InitializeOptions)(::windows_core::Interface::as_raw(self), funderstandnqs.into_param().abi(), fautowildcard.into_param().abi(), pqueryparser.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), option, poptionvalue).ok() + pub unsafe fn SetOption(&self, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), option, ::core::mem::transmute(poptionvalue)).ok() } } #[repr(C)] @@ -4154,10 +4112,7 @@ pub struct IQueryParserManager_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub CreateLoadedParser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszcatalog: ::windows_core::PCWSTR, langidforkeywords: u16, riid: *const ::windows_core::GUID, ppqueryparser: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub InitializeOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, funderstandnqs: super::super::Foundation::BOOL, fautowildcard: super::super::Foundation::BOOL, pqueryparser: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetOption: usize, + pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, option: QUERY_PARSER_MANAGER_OPTION, poptionvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IQuerySolution, IQuerySolution_Vtbl, 0xd6ebc66b_8921_4193_afdd_a1789fb7ff57); ::windows_core::imp::interface_hierarchy!(IQuerySolution, ::windows_core::IUnknown, IConditionFactory); @@ -4182,9 +4137,9 @@ impl IQuerySolution { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MakeAndOr)(::windows_core::Interface::as_raw(self), ct, peusubs.into_param().abi(), fsimplify.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] - pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const super::Com::StructuredStorage::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Search_Common\"`"] + #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Search_Common"))] + pub unsafe fn MakeLeaf(&self, pszpropertyname: P0, cop: Common::CONDITION_OPERATION, pszvaluetype: P1, ppropvar: *const ::windows_core::PROPVARIANT, ppropertynameterm: P2, poperationterm: P3, pvalueterm: P4, fexpand: P5) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -4194,7 +4149,7 @@ impl IQuerySolution { P5: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ppropvar, ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MakeLeaf)(::windows_core::Interface::as_raw(self), pszpropertyname.into_param().abi(), cop, pszvaluetype.into_param().abi(), ::core::mem::transmute(ppropvar), ppropertynameterm.into_param().abi(), poperationterm.into_param().abi(), pvalueterm.into_param().abi(), fexpand.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4321,9 +4276,7 @@ pub struct IRelationship_Vtbl { ::windows_core::imp::com_interface!(IRichChunk, IRichChunk_Vtbl, 0x4fdef69c_dbc9_454e_9910_b34f3c64b510); ::windows_core::imp::interface_hierarchy!(IRichChunk, ::windows_core::IUnknown); impl IRichChunk { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetData(&self, pfirstpos: ::core::option::Option<*mut u32>, plength: ::core::option::Option<*mut u32>, ppsz: ::core::option::Option<*mut ::windows_core::PWSTR>, pvalue: ::core::option::Option<*mut super::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn GetData(&self, pfirstpos: ::core::option::Option<*mut u32>, plength: ::core::option::Option<*mut u32>, ppsz: ::core::option::Option<*mut ::windows_core::PWSTR>, pvalue: ::core::option::Option<*mut ::windows_core::PROPVARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetData)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pfirstpos.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plength.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(ppsz.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(pvalue.unwrap_or(::std::ptr::null_mut()))).ok() } } @@ -4331,10 +4284,7 @@ impl IRichChunk { #[doc(hidden)] pub struct IRichChunk_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetData: usize, + pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfirstpos: *mut u32, plength: *mut u32, ppsz: *mut ::windows_core::PWSTR, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IRow, IRow_Vtbl, 0x0c733ab4_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IRow, ::windows_core::IUnknown); @@ -4622,8 +4572,8 @@ pub struct IRowsetCopyRows_Vtbl { ::windows_core::imp::com_interface!(IRowsetCurrentIndex, IRowsetCurrentIndex_Vtbl, 0x0c733abd_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IRowsetCurrentIndex, ::windows_core::IUnknown, IRowsetIndex); impl IRowsetCurrentIndex { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetIndexInfo(&self, pckeycolumns: *mut usize, prgindexcolumndesc: *mut *mut DBINDEXCOLUMNDESC, pcindexpropertysets: *mut u32, prgindexpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetIndexInfo)(::windows_core::Interface::as_raw(self), pckeycolumns, prgindexcolumndesc, pcindexpropertysets, prgindexpropertysets).ok() } @@ -4667,47 +4617,27 @@ pub struct IRowsetCurrentIndex_Vtbl { ::windows_core::imp::com_interface!(IRowsetEvents, IRowsetEvents_Vtbl, 0x1551aea5_5d66_4b11_86f5_d5634cb211b9); ::windows_core::imp::interface_hierarchy!(IRowsetEvents, ::windows_core::IUnknown); impl IRowsetEvents { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn OnNewItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnNewItem)(::windows_core::Interface::as_raw(self), itemid, newitemstate).ok() + pub unsafe fn OnNewItem(&self, itemid: *const ::windows_core::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnNewItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(itemid), newitemstate).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn OnChangedItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnChangedItem)(::windows_core::Interface::as_raw(self), itemid, rowsetitemstate, changeditemstate).ok() + pub unsafe fn OnChangedItem(&self, itemid: *const ::windows_core::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnChangedItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(itemid), rowsetitemstate, changeditemstate).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn OnDeletedItem(&self, itemid: *const super::Com::StructuredStorage::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnDeletedItem)(::windows_core::Interface::as_raw(self), itemid, deleteditemstate).ok() + pub unsafe fn OnDeletedItem(&self, itemid: *const ::windows_core::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnDeletedItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(itemid), deleteditemstate).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn OnRowsetEvent(&self, eventtype: ROWSETEVENT_TYPE, eventdata: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnRowsetEvent)(::windows_core::Interface::as_raw(self), eventtype, eventdata).ok() + pub unsafe fn OnRowsetEvent(&self, eventtype: ROWSETEVENT_TYPE, eventdata: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnRowsetEvent)(::windows_core::Interface::as_raw(self), eventtype, ::core::mem::transmute(eventdata)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IRowsetEvents_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub OnNewItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - OnNewItem: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub OnChangedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - OnChangedItem: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub OnDeletedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const super::Com::StructuredStorage::PROPVARIANT, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - OnDeletedItem: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub OnRowsetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eventtype: ROWSETEVENT_TYPE, eventdata: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - OnRowsetEvent: usize, + pub OnNewItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, newitemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, + pub OnChangedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, rowsetitemstate: ROWSETEVENT_ITEMSTATE, changeditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, + pub OnDeletedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, deleteditemstate: ROWSETEVENT_ITEMSTATE) -> ::windows_core::HRESULT, + pub OnRowsetEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, eventtype: ROWSETEVENT_TYPE, eventdata: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IRowsetExactScroll, IRowsetExactScroll_Vtbl, 0x0c733a7f_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IRowsetExactScroll, ::windows_core::IUnknown, IRowset, IRowsetLocate, IRowsetScroll); @@ -4814,8 +4744,8 @@ pub struct IRowsetIdentity_Vtbl { ::windows_core::imp::com_interface!(IRowsetIndex, IRowsetIndex_Vtbl, 0x0c733a82_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IRowsetIndex, ::windows_core::IUnknown); impl IRowsetIndex { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetIndexInfo(&self, pckeycolumns: *mut usize, prgindexcolumndesc: *mut *mut DBINDEXCOLUMNDESC, pcindexpropertysets: *mut u32, prgindexpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetIndexInfo)(::windows_core::Interface::as_raw(self), pckeycolumns, prgindexcolumndesc, pcindexpropertysets, prgindexpropertysets).ok() } @@ -4836,9 +4766,9 @@ impl IRowsetIndex { #[doc(hidden)] pub struct IRowsetIndex_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetIndexInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pckeycolumns: *mut usize, prgindexcolumndesc: *mut *mut DBINDEXCOLUMNDESC, pcindexpropertysets: *mut u32, prgindexpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetIndexInfo: usize, pub Seek: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, haccessor: HACCESSOR, ckeyvalues: usize, pdata: *const ::core::ffi::c_void, dwseekoptions: u32) -> ::windows_core::HRESULT, pub SetRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, haccessor: HACCESSOR, cstartkeycolumns: usize, pstartdata: *const ::core::ffi::c_void, cendkeycolumns: usize, penddata: *const ::core::ffi::c_void, dwrangeoptions: u32) -> ::windows_core::HRESULT, @@ -4846,8 +4776,8 @@ pub struct IRowsetIndex_Vtbl { ::windows_core::imp::com_interface!(IRowsetInfo, IRowsetInfo_Vtbl, 0x0c733a55_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(IRowsetInfo, ::windows_core::IUnknown); impl IRowsetInfo { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertysets, prgpropertysets).ok() } @@ -4864,9 +4794,9 @@ impl IRowsetInfo { #[doc(hidden)] pub struct IRowsetInfo_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetProperties: usize, pub GetReferencedRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iordinal: usize, riid: *const ::windows_core::GUID, ppreferencedrowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetSpecification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppspecification: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5311,8 +5241,6 @@ pub struct ISQLErrorInfo_Vtbl { ::windows_core::imp::com_interface!(ISQLGetDiagField, ISQLGetDiagField_Vtbl, 0x228972f1_b5ff_11d0_8a80_00c04fd611cd); ::windows_core::imp::interface_hierarchy!(ISQLGetDiagField, ::windows_core::IUnknown); impl ISQLGetDiagField { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn GetDiagField(&self, pdiaginfo: ::core::option::Option<*mut KAGGETDIAG>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetDiagField)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pdiaginfo.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -5321,10 +5249,7 @@ impl ISQLGetDiagField { #[doc(hidden)] pub struct ISQLGetDiagField_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub GetDiagField: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdiaginfo: *mut KAGGETDIAG) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDiagField: usize, } ::windows_core::imp::com_interface!(ISQLRequestDiagFields, ISQLRequestDiagFields_Vtbl, 0x228972f0_b5ff_11d0_8a80_00c04fd611cd); ::windows_core::imp::interface_hierarchy!(ISQLRequestDiagFields, ::windows_core::IUnknown); @@ -5492,8 +5417,8 @@ impl IScopedOperations { pub unsafe fn Delete(&self, crows: usize, rgpwszurls: *const ::windows_core::PCWSTR, dwdeleteflags: u32, rgdwstatus: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), crows, rgpwszurls, dwdeleteflags, rgdwstatus).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn OpenRowset(&self, punkouter: P0, ptableid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, pindexid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, riid: *const ::windows_core::GUID, rgpropertysets: &mut [DBPROPSET], pprowset: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -5514,9 +5439,9 @@ pub struct IScopedOperations_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Move: usize, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, crows: usize, rgpwszurls: *const ::windows_core::PCWSTR, dwdeleteflags: u32, rgdwstatus: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub OpenRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pindexid: *const super::super::Storage::IndexServer::DBID, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] OpenRowset: usize, } ::windows_core::imp::com_interface!(ISearchCatalogManager, ISearchCatalogManager_Vtbl, 0xab310581_ac80_11d1_8df3_00c04fb6ef50); @@ -5526,22 +5451,18 @@ impl ISearchCatalogManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT> + pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn GetCatalogStatus(&self, pstatus: *mut CatalogStatus, ppausedreason: *mut CatalogPausedReason) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCatalogStatus)(::windows_core::Interface::as_raw(self), pstatus, ppausedreason).ok() @@ -5656,14 +5577,8 @@ impl ISearchCatalogManager { pub struct ISearchCatalogManager_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetParameter: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetParameter: usize, + pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut ::windows_core::PROPVARIANT) -> ::windows_core::HRESULT, + pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetCatalogStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstatus: *mut CatalogStatus, ppausedreason: *mut CatalogPausedReason) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Reindex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -5698,22 +5613,18 @@ impl ISearchCatalogManager2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT> + pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).base__.SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn GetCatalogStatus(&self, pstatus: *mut CatalogStatus, ppausedreason: *mut CatalogPausedReason) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetCatalogStatus)(::windows_core::Interface::as_raw(self), pstatus, ppausedreason).ok() @@ -6149,22 +6060,18 @@ impl ISearchManager { pub unsafe fn GetIndexerVersion(&self, pdwmajor: *mut u32, pdwminor: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetIndexerVersion)(::windows_core::Interface::as_raw(self), pdwmajor, pdwminor).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT> + pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn ProxyName(&self) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6218,14 +6125,8 @@ pub struct ISearchManager_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetIndexerVersionStr: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszversionstring: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GetIndexerVersion: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwmajor: *mut u32, pdwminor: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetParameter: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetParameter: usize, + pub GetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppvalue: *mut *mut ::windows_core::PROPVARIANT) -> ::windows_core::HRESULT, + pub SetParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub ProxyName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszproxyname: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub BypassList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszbypasslist: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub SetProxy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, suseproxy: PROXY_ACCESS, flocalbypassproxy: super::super::Foundation::BOOL, dwportnumber: u32, pszproxyname: ::windows_core::PCWSTR, pszbypasslist: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, @@ -6246,22 +6147,18 @@ impl ISearchManager2 { pub unsafe fn GetIndexerVersion(&self, pdwmajor: *mut u32, pdwminor: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetIndexerVersion)(::windows_core::Interface::as_raw(self), pdwmajor, pdwminor).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut super::Com::StructuredStorage::PROPVARIANT> + pub unsafe fn GetParameter(&self, pszname: P0) -> ::windows_core::Result<*mut ::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetParameter(&self, pszname: P0, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), pvalue).ok() + (::windows_core::Interface::vtable(self).base__.SetParameter)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn ProxyName(&self) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); @@ -6555,8 +6452,8 @@ impl ISearchQueryHelper { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GenerateSQLFromUserQuery)(::windows_core::Interface::as_raw(self), pszquery.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub unsafe fn WriteProperties(&self, itemid: i32, dwnumberofcolumns: u32, pcolumns: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalues: *const SEARCH_COLUMN_PROPERTIES, pftgathermodifiedtime: *const super::super::Foundation::FILETIME) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).WriteProperties)(::windows_core::Interface::as_raw(self), itemid, dwnumberofcolumns, pcolumns, pvalues, pftgathermodifiedtime).ok() } @@ -6590,9 +6487,9 @@ pub struct ISearchQueryHelper_Vtbl { pub SetQuerySorting: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszsorting: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub QuerySorting: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszsorting: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GenerateSQLFromUserQuery: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszquery: ::windows_core::PCWSTR, ppszsql: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub WriteProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemid: i32, dwnumberofcolumns: u32, pcolumns: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, pvalues: *const SEARCH_COLUMN_PROPERTIES, pftgathermodifiedtime: *const super::super::Foundation::FILETIME) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] WriteProperties: usize, pub SetQueryMaxResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cmaxresults: i32) -> ::windows_core::HRESULT, pub QueryMaxResults: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcmaxresults: *mut i32) -> ::windows_core::HRESULT, @@ -6862,13 +6759,13 @@ pub struct IService_Vtbl { ::windows_core::imp::com_interface!(ISessionProperties, ISessionProperties_Vtbl, 0x0c733a85_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ISessionProperties, ::windows_core::IUnknown); impl ISessionProperties { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetProperties(&self, rgpropertyidsets: ::core::option::Option<&[DBPROPIDSET]>, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetProperties)(::windows_core::Interface::as_raw(self), rgpropertyidsets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertyidsets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), pcpropertysets, prgpropertysets).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn SetProperties(&self, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetProperties)(::windows_core::Interface::as_raw(self), rgpropertysets.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), ::core::mem::transmute(rgpropertysets.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr()))).ok() } @@ -6877,13 +6774,13 @@ impl ISessionProperties { #[doc(hidden)] pub struct ISessionProperties_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetProperties: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub SetProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] SetProperties: usize, } ::windows_core::imp::com_interface!(ISimpleCommandCreator, ISimpleCommandCreator_Vtbl, 0x5e341ab7_02d0_11d1_900c_00a0c9063796); @@ -6920,8 +6817,8 @@ pub struct ISimpleCommandCreator_Vtbl { ::windows_core::imp::com_interface!(ISourcesRowset, ISourcesRowset_Vtbl, 0x0c733a1e_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ISourcesRowset, ::windows_core::IUnknown); impl ISourcesRowset { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn GetSourcesRowset(&self, punkouter: P0, riid: *const ::windows_core::GUID, rgproperties: ::core::option::Option<&mut [DBPROPSET]>, ppsourcesrowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -6933,9 +6830,9 @@ impl ISourcesRowset { #[doc(hidden)] pub struct ISourcesRowset_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub GetSourcesRowset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, cpropertysets: u32, rgproperties: *mut DBPROPSET, ppsourcesrowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] GetSourcesRowset: usize, } ::windows_core::imp::com_interface!(IStemmer, IStemmer_Vtbl, 0xefbaf140_7f42_11ce_be57_00aa0051fe20); @@ -6976,15 +6873,11 @@ impl ISubscriptionItem { pub unsafe fn SetSubscriptionItemInfo(&self, psubscriptioniteminfo: *const SUBSCRIPTIONITEMINFO) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetSubscriptionItemInfo)(::windows_core::Interface::as_raw(self), psubscriptioniteminfo).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ReadProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ReadProperties)(::windows_core::Interface::as_raw(self), ncount, rgwszname, rgvalue).ok() + pub unsafe fn ReadProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ReadProperties)(::windows_core::Interface::as_raw(self), ncount, rgwszname, ::core::mem::transmute(rgvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn WriteProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).WriteProperties)(::windows_core::Interface::as_raw(self), ncount, rgwszname, rgvalue).ok() + pub unsafe fn WriteProperties(&self, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).WriteProperties)(::windows_core::Interface::as_raw(self), ncount, rgwszname, ::core::mem::transmute(rgvalue)).ok() } pub unsafe fn EnumProperties(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -7001,14 +6894,8 @@ pub struct ISubscriptionItem_Vtbl { pub GetCookie: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcookie: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetSubscriptionItemInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psubscriptioniteminfo: *mut SUBSCRIPTIONITEMINFO) -> ::windows_core::HRESULT, pub SetSubscriptionItemInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psubscriptioniteminfo: *const SUBSCRIPTIONITEMINFO) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ReadProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ReadProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub WriteProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - WriteProperties: usize, + pub ReadProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub WriteProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ncount: u32, rgwszname: *const ::windows_core::PCWSTR, rgvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EnumProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenumitemproperties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub NotifyChanged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -7169,8 +7056,8 @@ pub struct ISubscriptionMgr2_Vtbl { ::windows_core::imp::com_interface!(ITableCreation, ITableCreation_Vtbl, 0x0c733abc_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ITableCreation, ::windows_core::IUnknown, ITableDefinition); impl ITableCreation { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn CreateTable(&self, punkouter: P0, ptableid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, rgcolumndescs: ::core::option::Option<&[DBCOLUMNDESC]>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pptableid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>, pprowset: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -7194,8 +7081,8 @@ impl ITableCreation { pub unsafe fn DropTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DropTable)(::windows_core::Interface::as_raw(self), ptableid).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn AddColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumndesc: *const DBCOLUMNDESC, ppcolumnid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.AddColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumndesc, ::core::mem::transmute(ppcolumnid.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -7204,8 +7091,8 @@ impl ITableCreation { pub unsafe fn DropColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.DropColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumnid).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn GetTableDefinition(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pccolumndescs: ::core::option::Option<*mut usize>, prgcolumndescs: ::core::option::Option<*mut *mut DBCOLUMNDESC>, pcpropertysets: ::core::option::Option<*mut u32>, prgpropertysets: ::core::option::Option<*mut *mut DBPROPSET>, pcconstraintdescs: ::core::option::Option<*mut u32>, prgconstraintdescs: ::core::option::Option<*mut *mut DBCONSTRAINTDESC>, ppwszstringbuffer: ::core::option::Option<*mut *mut u16>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetTableDefinition)( ::windows_core::Interface::as_raw(self), @@ -7225,16 +7112,16 @@ impl ITableCreation { #[doc(hidden)] pub struct ITableCreation_Vtbl { pub base__: ITableDefinition_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub GetTableDefinition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pccolumndescs: *mut usize, prgcolumndescs: *mut *mut DBCOLUMNDESC, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET, pcconstraintdescs: *mut u32, prgconstraintdescs: *mut *mut DBCONSTRAINTDESC, ppwszstringbuffer: *mut *mut u16) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com")))] GetTableDefinition: usize, } ::windows_core::imp::com_interface!(ITableDefinition, ITableDefinition_Vtbl, 0x0c733a86_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ITableDefinition, ::windows_core::IUnknown); impl ITableDefinition { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn CreateTable(&self, punkouter: P0, ptableid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, rgcolumndescs: ::core::option::Option<&[DBCOLUMNDESC]>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pptableid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>, pprowset: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -7258,8 +7145,8 @@ impl ITableDefinition { pub unsafe fn DropTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DropTable)(::windows_core::Interface::as_raw(self), ptableid).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn AddColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumndesc: *const DBCOLUMNDESC, ppcolumnid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AddColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumndesc, ::core::mem::transmute(ppcolumnid.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -7273,17 +7160,17 @@ impl ITableDefinition { #[doc(hidden)] pub struct ITableDefinition_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub CreateTable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, ccolumndescs: usize, rgcolumndescs: *const DBCOLUMNDESC, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com")))] CreateTable: usize, #[cfg(feature = "Win32_Storage_IndexServer")] pub DropTable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_Storage_IndexServer"))] DropTable: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub AddColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumndesc: *const DBCOLUMNDESC, ppcolumnid: *mut *mut super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com")))] AddColumn: usize, #[cfg(feature = "Win32_Storage_IndexServer")] pub DropColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, @@ -7293,8 +7180,8 @@ pub struct ITableDefinition_Vtbl { ::windows_core::imp::com_interface!(ITableDefinitionWithConstraints, ITableDefinitionWithConstraints_Vtbl, 0x0c733aab_2a1c_11ce_ade5_00aa0044773d); ::windows_core::imp::interface_hierarchy!(ITableDefinitionWithConstraints, ::windows_core::IUnknown, ITableDefinition, ITableCreation); impl ITableDefinitionWithConstraints { - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn CreateTable(&self, punkouter: P0, ptableid: ::core::option::Option<*const super::super::Storage::IndexServer::DBID>, rgcolumndescs: ::core::option::Option<&[DBCOLUMNDESC]>, riid: *const ::windows_core::GUID, rgpropertysets: ::core::option::Option<&mut [DBPROPSET]>, pptableid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>, pprowset: ::core::option::Option<*mut ::core::option::Option<::windows_core::IUnknown>>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -7318,8 +7205,8 @@ impl ITableDefinitionWithConstraints { pub unsafe fn DropTable(&self, ptableid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.DropTable)(::windows_core::Interface::as_raw(self), ptableid).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn AddColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumndesc: *const DBCOLUMNDESC, ppcolumnid: ::core::option::Option<*mut *mut super::super::Storage::IndexServer::DBID>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.AddColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumndesc, ::core::mem::transmute(ppcolumnid.unwrap_or(::std::ptr::null_mut()))).ok() } @@ -7328,8 +7215,8 @@ impl ITableDefinitionWithConstraints { pub unsafe fn DropColumn(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pcolumnid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.DropColumn)(::windows_core::Interface::as_raw(self), ptableid, pcolumnid).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn GetTableDefinition(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pccolumndescs: ::core::option::Option<*mut usize>, prgcolumndescs: ::core::option::Option<*mut *mut DBCOLUMNDESC>, pcpropertysets: ::core::option::Option<*mut u32>, prgpropertysets: ::core::option::Option<*mut *mut DBPROPSET>, pcconstraintdescs: ::core::option::Option<*mut u32>, prgconstraintdescs: ::core::option::Option<*mut *mut DBCONSTRAINTDESC>, ppwszstringbuffer: ::core::option::Option<*mut *mut u16>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetTableDefinition)( ::windows_core::Interface::as_raw(self), @@ -7344,13 +7231,13 @@ impl ITableDefinitionWithConstraints { ) .ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] + #[cfg(feature = "Win32_Storage_IndexServer")] pub unsafe fn AddConstraint(&self, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintdesc: *const DBCONSTRAINTDESC) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AddConstraint)(::windows_core::Interface::as_raw(self), ptableid, pconstraintdesc).ok() } - #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub unsafe fn CreateTableWithConstraints(&self, punkouter: P0, ptableid: *const super::super::Storage::IndexServer::DBID, rgcolumndescs: &mut [DBCOLUMNDESC], rgconstraintdescs: &[DBCONSTRAINTDESC], riid: *const ::windows_core::GUID, rgpropertysets: &mut [DBPROPSET], pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut ::core::option::Option<::windows_core::IUnknown>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, @@ -7367,13 +7254,13 @@ impl ITableDefinitionWithConstraints { #[doc(hidden)] pub struct ITableDefinitionWithConstraints_Vtbl { pub base__: ITableCreation_Vtbl, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_Storage_IndexServer")] pub AddConstraint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintdesc: *const DBCONSTRAINTDESC) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_Storage_IndexServer"))] AddConstraint: usize, - #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub CreateTableWithConstraints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkouter: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, ccolumndescs: usize, rgcolumndescs: *mut DBCOLUMNDESC, cconstraintdescs: u32, rgconstraintdescs: *const DBCONSTRAINTDESC, riid: *const ::windows_core::GUID, cpropertysets: u32, rgpropertysets: *mut DBPROPSET, pptableid: *mut *mut super::super::Storage::IndexServer::DBID, pprowset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com")))] CreateTableWithConstraints: usize, #[cfg(feature = "Win32_Storage_IndexServer")] pub DropConstraint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptableid: *const super::super::Storage::IndexServer::DBID, pconstraintid: *const super::super::Storage::IndexServer::DBID) -> ::windows_core::HRESULT, @@ -7545,8 +7432,8 @@ impl ITrusteeAdmin { pub unsafe fn CompareTrustees(&self, ptrustee1: *const super::super::Security::Authorization::TRUSTEE_W, ptrustee2: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).CompareTrustees)(::windows_core::Interface::as_raw(self), ptrustee1, ptrustee2).ok() } - #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`"] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub unsafe fn CreateTrustee(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, rgpropertysets: &mut [DBPROPSET]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).CreateTrustee)(::windows_core::Interface::as_raw(self), ptrustee, rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr())).ok() } @@ -7555,13 +7442,13 @@ impl ITrusteeAdmin { pub unsafe fn DeleteTrustee(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DeleteTrustee)(::windows_core::Interface::as_raw(self), ptrustee).ok() } - #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`"] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub unsafe fn SetTrusteeProperties(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, rgpropertysets: &mut [DBPROPSET]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetTrusteeProperties)(::windows_core::Interface::as_raw(self), ptrustee, rgpropertysets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertysets.as_ptr())).ok() } - #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_Security_Authorization\"`, `\"Win32_Storage_IndexServer\"`"] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub unsafe fn GetTrusteeProperties(&self, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, rgpropertyidsets: &[DBPROPIDSET], pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetTrusteeProperties)(::windows_core::Interface::as_raw(self), ptrustee, rgpropertyidsets.len().try_into().unwrap(), ::core::mem::transmute(rgpropertyidsets.as_ptr()), pcpropertysets, prgpropertysets).ok() } @@ -7574,21 +7461,21 @@ pub struct ITrusteeAdmin_Vtbl { pub CompareTrustees: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptrustee1: *const super::super::Security::Authorization::TRUSTEE_W, ptrustee2: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_Security_Authorization"))] CompareTrustees: usize, - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub CreateTrustee: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer")))] CreateTrustee: usize, #[cfg(feature = "Win32_Security_Authorization")] pub DeleteTrustee: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_Security_Authorization"))] DeleteTrustee: usize, - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub SetTrusteeProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertysets: u32, rgpropertysets: *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer")))] SetTrusteeProperties: usize, - #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer"))] pub GetTrusteeProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ptrustee: *const super::super::Security::Authorization::TRUSTEE_W, cpropertyidsets: u32, rgpropertyidsets: *const DBPROPIDSET, pcpropertysets: *mut u32, prgpropertysets: *mut *mut DBPROPSET) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(all(feature = "Win32_Security_Authorization", feature = "Win32_Storage_IndexServer")))] GetTrusteeProperties: usize, } ::windows_core::imp::com_interface!(ITrusteeGroupAdmin, ITrusteeGroupAdmin_Vtbl, 0x0c733aa2_2a1c_11ce_ade5_00aa0044773d); @@ -7689,10 +7576,10 @@ pub struct IUMSInitialize_Vtbl { ::windows_core::imp::com_interface!(IUrlAccessor, IUrlAccessor_Vtbl, 0x0b63e318_9ccc_11d0_bcdb_00805fccce04); ::windows_core::imp::interface_hierarchy!(IUrlAccessor, ::windows_core::IUnknown); impl IUrlAccessor { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, pvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, ::core::mem::transmute(pvar)).ok() } pub unsafe fn GetDocFormat(&self, wszdocformat: &mut [u16], pdwlength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetDocFormat)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wszdocformat.as_ptr()), wszdocformat.len().try_into().unwrap(), pdwlength).ok() @@ -7745,9 +7632,9 @@ impl IUrlAccessor { #[doc(hidden)] pub struct IUrlAccessor_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub AddRequestParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub AddRequestParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com_StructuredStorage"))] AddRequestParameter: usize, pub GetDocFormat: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszdocformat: ::windows_core::PWSTR, dwsize: u32, pdwlength: *mut u32) -> ::windows_core::HRESULT, pub GetCLSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pclsid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, @@ -7771,10 +7658,10 @@ pub struct IUrlAccessor_Vtbl { ::windows_core::imp::com_interface!(IUrlAccessor2, IUrlAccessor2_Vtbl, 0xc7310734_ac80_11d1_8df3_00c04fb6ef4f); ::windows_core::imp::interface_hierarchy!(IUrlAccessor2, ::windows_core::IUnknown, IUrlAccessor); impl IUrlAccessor2 { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, pvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, ::core::mem::transmute(pvar)).ok() } pub unsafe fn GetDocFormat(&self, wszdocformat: &mut [u16], pdwlength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetDocFormat)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wszdocformat.as_ptr()), wszdocformat.len().try_into().unwrap(), pdwlength).ok() @@ -7843,10 +7730,10 @@ pub struct IUrlAccessor2_Vtbl { ::windows_core::imp::com_interface!(IUrlAccessor3, IUrlAccessor3_Vtbl, 0x6fbc7005_0455_4874_b8ff_7439450241a3); ::windows_core::imp::interface_hierarchy!(IUrlAccessor3, ::windows_core::IUnknown, IUrlAccessor, IUrlAccessor2); impl IUrlAccessor3 { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, pvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, ::core::mem::transmute(pvar)).ok() } pub unsafe fn GetDocFormat(&self, wszdocformat: &mut [u16], pdwlength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GetDocFormat)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wszdocformat.as_ptr()), wszdocformat.len().try_into().unwrap(), pdwlength).ok() @@ -7924,10 +7811,10 @@ pub struct IUrlAccessor3_Vtbl { ::windows_core::imp::com_interface!(IUrlAccessor4, IUrlAccessor4_Vtbl, 0x5cc51041_c8d2_41d7_bca3_9e9e286297dc); ::windows_core::imp::interface_hierarchy!(IUrlAccessor4, ::windows_core::IUnknown, IUrlAccessor, IUrlAccessor2, IUrlAccessor3); impl IUrlAccessor4 { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, pvar).ok() + #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] + #[cfg(feature = "Win32_System_Com_StructuredStorage")] + pub unsafe fn AddRequestParameter(&self, pspec: *const super::Com::StructuredStorage::PROPSPEC, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.AddRequestParameter)(::windows_core::Interface::as_raw(self), pspec, ::core::mem::transmute(pvar)).ok() } pub unsafe fn GetDocFormat(&self, wszdocformat: &mut [u16], pdwlength: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.GetDocFormat)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(wszdocformat.as_ptr()), wszdocformat.len().try_into().unwrap(), pdwlength).ok() @@ -8222,16 +8109,15 @@ impl OLEDBSimpleProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getRWStatus)(::windows_core::Interface::as_raw(self), irow, icolumn, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT) -> ::windows_core::Result { + pub unsafe fn getVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getVariant)(::windows_core::Interface::as_raw(self), irow, icolumn, format, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT, var: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).setVariant)(::windows_core::Interface::as_raw(self), irow, icolumn, format, ::core::mem::transmute(var)).ok() + pub unsafe fn setVariant(&self, irow: isize, icolumn: isize, format: OSPFORMAT, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).setVariant)(::windows_core::Interface::as_raw(self), irow, icolumn, format, var.into_param().abi()).ok() } pub unsafe fn getLocale(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -8245,11 +8131,12 @@ impl OLEDBSimpleProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).insertRows)(::windows_core::Interface::as_raw(self), irow, crows, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn find(&self, irowstart: isize, icolumn: isize, val: super::Variant::VARIANT, findflags: OSPFIND, comptype: OSPCOMP) -> ::windows_core::Result { + pub unsafe fn find(&self, irowstart: isize, icolumn: isize, val: P0, findflags: OSPFIND, comptype: OSPCOMP) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).find)(::windows_core::Interface::as_raw(self), irowstart, icolumn, ::core::mem::transmute(val), findflags, comptype, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).find)(::windows_core::Interface::as_raw(self), irowstart, icolumn, val.into_param().abi(), findflags, comptype, &mut result__).from_abi(result__) } pub unsafe fn addOLEDBSimpleProviderListener(&self, pospilistener: P0) -> ::windows_core::Result<()> where @@ -8282,21 +8169,12 @@ pub struct OLEDBSimpleProvider_Vtbl { pub getRowCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcrows: *mut isize) -> ::windows_core::HRESULT, pub getColumnCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pccolumns: *mut isize) -> ::windows_core::HRESULT, pub getRWStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, prwstatus: *mut OSPRW) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, pvar: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getVariant: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, var: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setVariant: usize, + pub getVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, icolumn: isize, format: OSPFORMAT, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub getLocale: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrlocale: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub deleteRows: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, crows: isize, pcrowsdeleted: *mut isize) -> ::windows_core::HRESULT, pub insertRows: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irow: isize, crows: isize, pcrowsinserted: *mut isize) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub find: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irowstart: isize, icolumn: isize, val: super::Variant::VARIANT, findflags: OSPFIND, comptype: OSPCOMP, pirowfound: *mut isize) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - find: usize, + pub find: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, irowstart: isize, icolumn: isize, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, findflags: OSPFIND, comptype: OSPCOMP, pirowfound: *mut isize) -> ::windows_core::HRESULT, pub addOLEDBSimpleProviderListener: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pospilistener: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub removeOLEDBSimpleProviderListener: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pospilistener: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub isAsync: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbasynch: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, @@ -14346,91 +14224,91 @@ impl ::core::default::Default for BUCKETCATEGORIZE { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct CATEGORIZATION { pub ulCatType: u32, pub Anonymous: CATEGORIZATION_0, pub csColumns: COLUMNSET, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for CATEGORIZATION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for CATEGORIZATION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for CATEGORIZATION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for CATEGORIZATION { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub union CATEGORIZATION_0 { pub cClusters: u32, pub bucket: BUCKETCATEGORIZE, pub range: RANGECATEGORIZE, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for CATEGORIZATION_0 {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for CATEGORIZATION_0 { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for CATEGORIZATION_0 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for CATEGORIZATION_0 { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct CATEGORIZATIONSET { pub cCat: u32, pub aCat: *mut CATEGORIZATION, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for CATEGORIZATIONSET {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for CATEGORIZATIONSET { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::fmt::Debug for CATEGORIZATIONSET { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("CATEGORIZATIONSET").field("cCat", &self.cCat).field("aCat", &self.aCat).finish() } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for CATEGORIZATIONSET { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::PartialEq for CATEGORIZATIONSET { fn eq(&self, other: &Self) -> bool { self.cCat == other.cCat && self.aCat == other.aCat } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::Eq for CATEGORIZATIONSET {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for CATEGORIZATIONSET { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -14729,9 +14607,9 @@ impl ::core::default::Default for DBCOLUMNACCESS { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub struct DBCOLUMNDESC { pub pwszTypeName: ::windows_core::PWSTR, pub pTypeInfo: ::std::mem::ManuallyDrop<::core::option::Option>, @@ -14745,28 +14623,28 @@ pub struct DBCOLUMNDESC { pub bScale: u8, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::core::clone::Clone for DBCOLUMNDESC { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::TypeKind for DBCOLUMNDESC { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::core::default::Default for DBCOLUMNDESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] pub struct DBCOLUMNDESC { pub pwszTypeName: ::windows_core::PWSTR, pub pTypeInfo: ::std::mem::ManuallyDrop<::core::option::Option>, @@ -14780,12 +14658,12 @@ pub struct DBCOLUMNDESC { pub bScale: u8, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::windows_core::TypeKind for DBCOLUMNDESC { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com"))] impl ::core::default::Default for DBCOLUMNDESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -14853,9 +14731,9 @@ impl ::core::default::Default for DBCOLUMNINFO { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBCONSTRAINTDESC { pub pConstraintID: *mut super::super::Storage::IndexServer::DBID, pub ConstraintType: u32, @@ -14873,31 +14751,31 @@ pub struct DBCONSTRAINTDESC { pub rgReserved: *mut DBPROPSET, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::marker::Copy for DBCONSTRAINTDESC {} #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::clone::Clone for DBCONSTRAINTDESC { fn clone(&self) -> Self { *self } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBCONSTRAINTDESC { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBCONSTRAINTDESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBCONSTRAINTDESC { pub pConstraintID: *mut super::super::Storage::IndexServer::DBID, pub ConstraintType: u32, @@ -14915,22 +14793,22 @@ pub struct DBCONSTRAINTDESC { pub rgReserved: *mut DBPROPSET, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::marker::Copy for DBCONSTRAINTDESC {} #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::clone::Clone for DBCONSTRAINTDESC { fn clone(&self) -> Self { *self } } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBCONSTRAINTDESC { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBCONSTRAINTDESC { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -15527,53 +15405,53 @@ impl ::core::default::Default for DBPARAMS { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBPROP { pub dwPropertyID: u32, pub dwOptions: u32, pub dwStatus: u32, pub colid: super::super::Storage::IndexServer::DBID, - pub vValue: super::Variant::VARIANT, + pub vValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::clone::Clone for DBPROP { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBPROP { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBPROP { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBPROP { pub dwPropertyID: u32, pub dwOptions: u32, pub dwStatus: u32, pub colid: super::super::Storage::IndexServer::DBID, - pub vValue: super::Variant::VARIANT, + pub vValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBPROP { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBPROP { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -15630,177 +15508,177 @@ impl ::core::default::Default for DBPROPIDSET { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] pub struct DBPROPINFO { pub pwszDescription: ::windows_core::PWSTR, pub dwPropertyID: u32, pub dwFlags: u32, pub vtType: super::Variant::VARENUM, - pub vValues: super::Variant::VARIANT, + pub vValues: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::clone::Clone for DBPROPINFO { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::TypeKind for DBPROPINFO { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::default::Default for DBPROPINFO { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] pub struct DBPROPINFO { pub pwszDescription: ::windows_core::PWSTR, pub dwPropertyID: u32, pub dwFlags: u32, pub vtType: super::Variant::VARENUM, - pub vValues: super::Variant::VARIANT, + pub vValues: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::TypeKind for DBPROPINFO { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::default::Default for DBPROPINFO { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] pub struct DBPROPINFOSET { pub rgPropertyInfos: *mut DBPROPINFO, pub cPropertyInfos: u32, pub guidPropertySet: ::windows_core::GUID, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::marker::Copy for DBPROPINFOSET {} #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::clone::Clone for DBPROPINFOSET { fn clone(&self) -> Self { *self } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::TypeKind for DBPROPINFOSET { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::default::Default for DBPROPINFOSET { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Variant\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] pub struct DBPROPINFOSET { pub rgPropertyInfos: *mut DBPROPINFO, pub cPropertyInfos: u32, pub guidPropertySet: ::windows_core::GUID, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::marker::Copy for DBPROPINFOSET {} #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::clone::Clone for DBPROPINFOSET { fn clone(&self) -> Self { *self } } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::windows_core::TypeKind for DBPROPINFOSET { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Variant")] impl ::core::default::Default for DBPROPINFOSET { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBPROPSET { pub rgProperties: *mut DBPROP, pub cProperties: u32, pub guidPropertySet: ::windows_core::GUID, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::marker::Copy for DBPROPSET {} #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::clone::Clone for DBPROPSET { fn clone(&self) -> Self { *self } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBPROPSET { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBPROPSET { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] pub struct DBPROPSET { pub rgProperties: *mut DBPROP, pub cProperties: u32, pub guidPropertySet: ::windows_core::GUID, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::marker::Copy for DBPROPSET {} #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::clone::Clone for DBPROPSET { fn clone(&self) -> Self { *self } } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::windows_core::TypeKind for DBPROPSET { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_Storage_IndexServer")] impl ::core::default::Default for DBPROPSET { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16120,23 +15998,29 @@ impl ::core::default::Default for DB_VARNUMERIC { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct DCINFO { pub eInfoType: u32, - pub vData: super::Variant::VARIANT, + pub vData: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for DCINFO { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for DCINFO { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("DCINFO").field("eInfoType", &self.eInfoType).field("vData", &self.vData).finish() + } +} impl ::windows_core::TypeKind for DCINFO { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for DCINFO { + fn eq(&self, other: &Self) -> bool { + self.eInfoType == other.eInfoType && self.vData == other.vData + } +} +impl ::core::cmp::Eq for DCINFO {} impl ::core::default::Default for DCINFO { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16316,23 +16200,29 @@ impl ::core::default::Default for INCREMENTAL_ACCESS_INFO { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct ITEMPROP { - pub variantValue: super::Variant::VARIANT, + pub variantValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub pwszName: ::windows_core::PWSTR, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for ITEMPROP { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for ITEMPROP { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("ITEMPROP").field("variantValue", &self.variantValue).field("pwszName", &self.pwszName).finish() + } +} impl ::windows_core::TypeKind for ITEMPROP { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for ITEMPROP { + fn eq(&self, other: &Self) -> bool { + self.variantValue == other.variantValue && self.pwszName == other.pwszName + } +} +impl ::core::cmp::Eq for ITEMPROP {} impl ::core::default::Default for ITEMPROP { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16372,24 +16262,30 @@ impl ::core::default::Default for ITEM_INFO { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct KAGGETDIAG { pub ulSize: u32, - pub vDiagInfo: super::Variant::VARIANT, + pub vDiagInfo: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub sDiagField: i16, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for KAGGETDIAG { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for KAGGETDIAG { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("KAGGETDIAG").field("ulSize", &self.ulSize).field("vDiagInfo", &self.vDiagInfo).field("sDiagField", &self.sDiagField).finish() + } +} impl ::windows_core::TypeKind for KAGGETDIAG { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for KAGGETDIAG { + fn eq(&self, other: &Self) -> bool { + self.ulSize == other.ulSize && self.vDiagInfo == other.vDiagInfo && self.sDiagField == other.sDiagField + } +} +impl ::core::cmp::Eq for KAGGETDIAG {} impl ::core::default::Default for KAGGETDIAG { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16518,78 +16414,78 @@ impl ::core::default::Default for NATLANGUAGERESTRICTION { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct NODERESTRICTION { pub cRes: u32, pub paRes: *mut *mut RESTRICTION, pub reserved: u32, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for NODERESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for NODERESTRICTION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::fmt::Debug for NODERESTRICTION { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("NODERESTRICTION").field("cRes", &self.cRes).field("paRes", &self.paRes).field("reserved", &self.reserved).finish() } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for NODERESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::PartialEq for NODERESTRICTION { fn eq(&self, other: &Self) -> bool { self.cRes == other.cRes && self.paRes == other.paRes && self.reserved == other.reserved } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::Eq for NODERESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for NODERESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct NOTRESTRICTION { pub pRes: *mut RESTRICTION, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for NOTRESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for NOTRESTRICTION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::fmt::Debug for NOTRESTRICTION { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("NOTRESTRICTION").field("pRes", &self.pRes).finish() } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for NOTRESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::PartialEq for NOTRESTRICTION { fn eq(&self, other: &Self) -> bool { self.pRes == other.pRes } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::Eq for NOTRESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for NOTRESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16656,24 +16552,24 @@ impl ::core::default::Default for ODBC_VS_ARGS_1 { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct PROPERTYRESTRICTION { pub rel: u32, pub prop: super::super::Storage::IndexServer::FULLPROPSPEC, - pub prval: super::Com::StructuredStorage::PROPVARIANT, + pub prval: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for PROPERTYRESTRICTION { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for PROPERTYRESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for PROPERTYRESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16715,71 +16611,62 @@ impl ::core::default::Default for PROXY_INFO { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct RANGECATEGORIZE { pub cRange: u32, - pub aRangeBegin: *mut super::Com::StructuredStorage::PROPVARIANT, + pub aRangeBegin: *mut ::windows_core::PROPVARIANT, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for RANGECATEGORIZE {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for RANGECATEGORIZE { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for RANGECATEGORIZE { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("RANGECATEGORIZE").field("cRange", &self.cRange).field("aRangeBegin", &self.aRangeBegin).finish() } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for RANGECATEGORIZE { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for RANGECATEGORIZE { fn eq(&self, other: &Self) -> bool { self.cRange == other.cRange && self.aRangeBegin == other.aRangeBegin } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for RANGECATEGORIZE {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::default::Default for RANGECATEGORIZE { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct RESTRICTION { pub rt: u32, pub weight: u32, pub res: RESTRICTION_0, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for RESTRICTION { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for RESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for RESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub union RESTRICTION_0 { pub ar: NODERESTRICTION, pub orRestriction: NODERESTRICTION, @@ -16790,111 +16677,117 @@ pub union RESTRICTION_0 { pub nlr: NATLANGUAGERESTRICTION, pub pr: ::std::mem::ManuallyDrop, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for RESTRICTION_0 { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for RESTRICTION_0 { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for RESTRICTION_0 { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] pub struct RMTPACK { pub pISeqStream: ::std::mem::ManuallyDrop<::core::option::Option>, pub cbData: u32, pub cBSTR: u32, pub rgBSTR: *mut ::windows_core::BSTR, pub cVARIANT: u32, - pub rgVARIANT: *mut super::Variant::VARIANT, + pub rgVARIANT: *mut ::windows_core::VARIANT, pub cIDISPATCH: u32, pub rgIDISPATCH: *mut ::core::option::Option, pub cIUNKNOWN: u32, pub rgIUNKNOWN: *mut ::core::option::Option<::windows_core::IUnknown>, pub cPROPVARIANT: u32, - pub rgPROPVARIANT: *mut super::Com::StructuredStorage::PROPVARIANT, + pub rgPROPVARIANT: *mut ::windows_core::PROPVARIANT, pub cArray: u32, - pub rgArray: *mut super::Variant::VARIANT, + pub rgArray: *mut ::windows_core::VARIANT, } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::core::clone::Clone for RMTPACK { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::TypeKind for RMTPACK { type TypeKind = ::windows_core::CopyType; } #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::core::default::Default for RMTPACK { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C, packed(2))] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] +#[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] pub struct RMTPACK { pub pISeqStream: ::std::mem::ManuallyDrop<::core::option::Option>, pub cbData: u32, pub cBSTR: u32, pub rgBSTR: *mut ::windows_core::BSTR, pub cVARIANT: u32, - pub rgVARIANT: *mut super::Variant::VARIANT, + pub rgVARIANT: *mut ::windows_core::VARIANT, pub cIDISPATCH: u32, pub rgIDISPATCH: *mut ::core::option::Option, pub cIUNKNOWN: u32, pub rgIUNKNOWN: *mut ::core::option::Option<::windows_core::IUnknown>, pub cPROPVARIANT: u32, - pub rgPROPVARIANT: *mut super::Com::StructuredStorage::PROPVARIANT, + pub rgPROPVARIANT: *mut ::windows_core::PROPVARIANT, pub cArray: u32, - pub rgArray: *mut super::Variant::VARIANT, + pub rgArray: *mut ::windows_core::VARIANT, } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::TypeKind for RMTPACK { type TypeKind = ::windows_core::CopyType; } #[cfg(target_arch = "x86")] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::core::default::Default for RMTPACK { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub struct SEARCH_COLUMN_PROPERTIES { - pub Value: super::Com::StructuredStorage::PROPVARIANT, + pub Value: ::std::mem::ManuallyDrop<::windows_core::PROPVARIANT>, pub lcid: u32, } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for SEARCH_COLUMN_PROPERTIES { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for SEARCH_COLUMN_PROPERTIES { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("SEARCH_COLUMN_PROPERTIES").field("Value", &self.Value).field("lcid", &self.lcid).finish() + } +} impl ::windows_core::TypeKind for SEARCH_COLUMN_PROPERTIES { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for SEARCH_COLUMN_PROPERTIES { + fn eq(&self, other: &Self) -> bool { + self.Value == other.Value && self.lcid == other.lcid + } +} +impl ::core::cmp::Eq for SEARCH_COLUMN_PROPERTIES {} impl ::core::default::Default for SEARCH_COLUMN_PROPERTIES { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -17978,39 +17871,39 @@ impl ::core::default::Default for TIME_STRUCT { } } #[repr(C)] -#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Storage_IndexServer\"`, `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] pub struct VECTORRESTRICTION { pub Node: NODERESTRICTION, pub RankMethod: u32, } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::marker::Copy for VECTORRESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::clone::Clone for VECTORRESTRICTION { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::fmt::Debug for VECTORRESTRICTION { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("VECTORRESTRICTION").field("Node", &self.Node).field("RankMethod", &self.RankMethod).finish() } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::windows_core::TypeKind for VECTORRESTRICTION { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::PartialEq for VECTORRESTRICTION { fn eq(&self, other: &Self) -> bool { self.Node == other.Node && self.RankMethod == other.RankMethod } } -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::cmp::Eq for VECTORRESTRICTION {} -#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Storage_IndexServer", feature = "Win32_System_Com_StructuredStorage"))] impl ::core::default::Default for VECTORRESTRICTION { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/System/SecurityCenter/impl.rs b/crates/libs/windows/src/Windows/Win32/System/SecurityCenter/impl.rs index 4075f78ccd..29de16ef53 100644 --- a/crates/libs/windows/src/Windows/Win32/System/SecurityCenter/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/SecurityCenter/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSCDefaultProduct_Impl: Sized + super::Com::IDispatch_Impl { fn SetDefaultProduct(&self, etype: SECURITY_PRODUCT_TYPE, pguid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSCDefaultProduct {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSCDefaultProduct_Vtbl { pub const fn new, Impl: IWSCDefaultProduct_Impl, const OFFSET: isize>() -> IWSCDefaultProduct_Vtbl { unsafe extern "system" fn SetDefaultProduct, Impl: IWSCDefaultProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, etype: SECURITY_PRODUCT_TYPE, pguid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -19,16 +19,16 @@ impl IWSCDefaultProduct_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWSCProductList_Impl: Sized + super::Com::IDispatch_Impl { fn Initialize(&self, provider: &WSC_SECURITY_PROVIDER) -> ::windows_core::Result<()>; fn Count(&self) -> ::windows_core::Result; fn get_Item(&self, index: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWSCProductList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWSCProductList_Vtbl { pub const fn new, Impl: IWSCProductList_Impl, const OFFSET: isize>() -> IWSCProductList_Vtbl { unsafe extern "system" fn Initialize, Impl: IWSCProductList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, provider: u32) -> ::windows_core::HRESULT { @@ -69,8 +69,8 @@ impl IWSCProductList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWscProduct_Impl: Sized + super::Com::IDispatch_Impl { fn ProductName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ProductState(&self) -> ::windows_core::Result; @@ -80,9 +80,9 @@ pub trait IWscProduct_Impl: Sized + super::Com::IDispatch_Impl { fn ProductGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ProductIsDefault(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWscProduct {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWscProduct_Vtbl { pub const fn new, Impl: IWscProduct_Impl, const OFFSET: isize>() -> IWscProduct_Vtbl { unsafe extern "system" fn ProductName, Impl: IWscProduct_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -177,8 +177,8 @@ impl IWscProduct_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWscProduct2_Impl: Sized + IWscProduct_Impl { fn AntivirusScanSubstatus(&self) -> ::windows_core::Result; fn AntivirusSettingsSubstatus(&self) -> ::windows_core::Result; @@ -187,9 +187,9 @@ pub trait IWscProduct2_Impl: Sized + IWscProduct_Impl { fn FirewallPrivateProfileSubstatus(&self) -> ::windows_core::Result; fn FirewallPublicProfileSubstatus(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWscProduct2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWscProduct2_Vtbl { pub const fn new, Impl: IWscProduct2_Impl, const OFFSET: isize>() -> IWscProduct2_Vtbl { unsafe extern "system" fn AntivirusScanSubstatus, Impl: IWscProduct2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pestatus: *mut WSC_SECURITY_PRODUCT_SUBSTATUS) -> ::windows_core::HRESULT { @@ -272,14 +272,14 @@ impl IWscProduct2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWscProduct3_Impl: Sized + IWscProduct2_Impl { fn AntivirusDaysUntilExpired(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWscProduct3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWscProduct3_Vtbl { pub const fn new, Impl: IWscProduct3_Impl, const OFFSET: isize>() -> IWscProduct3_Vtbl { unsafe extern "system" fn AntivirusDaysUntilExpired, Impl: IWscProduct3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwdays: *mut u32) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/impl.rs b/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/impl.rs index 58797217d2..116fe18690 100644 --- a/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/impl.rs @@ -1,16 +1,12 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IItemEnumerator_Impl: Sized { - fn Current(&self) -> ::windows_core::Result; + fn Current(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn MoveNext(&self) -> ::windows_core::Result; fn Reset(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IItemEnumerator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IItemEnumerator_Vtbl { pub const fn new, Impl: IItemEnumerator_Impl, const OFFSET: isize>() -> IItemEnumerator_Vtbl { - unsafe extern "system" fn Current, Impl: IItemEnumerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Current, Impl: IItemEnumerator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, item: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Current() { @@ -126,8 +122,8 @@ impl ISettingsContext_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISettingsEngine_Impl: Sized { fn GetNamespaces(&self, flags: WcmNamespaceEnumerationFlags, reserved: *const ::core::ffi::c_void) -> ::windows_core::Result; fn GetNamespace(&self, settingsid: ::core::option::Option<&ISettingsIdentity>, access: WcmNamespaceAccess, reserved: *const ::core::ffi::c_void) -> ::windows_core::Result; @@ -136,7 +132,7 @@ pub trait ISettingsEngine_Impl: Sized { fn GetStoreStatus(&self, reserved: *const ::core::ffi::c_void) -> ::windows_core::Result; fn LoadStore(&self, flags: u32) -> ::windows_core::Result<()>; fn UnloadStore(&self, reserved: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn RegisterNamespace(&self, settingsid: ::core::option::Option<&ISettingsIdentity>, stream: ::core::option::Option<&super::Com::IStream>, pushsettings: super::super::Foundation::BOOL) -> ::windows_core::Result; + fn RegisterNamespace(&self, settingsid: ::core::option::Option<&ISettingsIdentity>, stream: ::core::option::Option<&super::Com::IStream>, pushsettings: super::super::Foundation::BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; fn UnregisterNamespace(&self, settingsid: ::core::option::Option<&ISettingsIdentity>, removesettings: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn CreateTargetInfo(&self) -> ::windows_core::Result; fn GetTargetInfo(&self) -> ::windows_core::Result; @@ -146,9 +142,9 @@ pub trait ISettingsEngine_Impl: Sized { fn ApplySettingsContext(&self, settingscontext: ::core::option::Option<&ISettingsContext>, pppwzidentities: *mut *mut ::windows_core::PWSTR, pcidentities: *mut usize) -> ::windows_core::Result<()>; fn GetSettingsContext(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISettingsEngine {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISettingsEngine_Vtbl { pub const fn new, Impl: ISettingsEngine_Impl, const OFFSET: isize>() -> ISettingsEngine_Vtbl { unsafe extern "system" fn GetNamespaces, Impl: ISettingsEngine_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: WcmNamespaceEnumerationFlags, reserved: *const ::core::ffi::c_void, namespaces: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -216,7 +212,7 @@ impl ISettingsEngine_Vtbl { let this = (*this).get_impl(); this.UnloadStore(::core::mem::transmute_copy(&reserved)).into() } - unsafe extern "system" fn RegisterNamespace, Impl: ISettingsEngine_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, settingsid: *mut ::core::ffi::c_void, stream: *mut ::core::ffi::c_void, pushsettings: super::super::Foundation::BOOL, results: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterNamespace, Impl: ISettingsEngine_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, settingsid: *mut ::core::ffi::c_void, stream: *mut ::core::ffi::c_void, pushsettings: super::super::Foundation::BOOL, results: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RegisterNamespace(::windows_core::from_raw_borrowed(&settingsid), ::windows_core::from_raw_borrowed(&stream), ::core::mem::transmute_copy(&pushsettings)) { @@ -368,12 +364,10 @@ impl ISettingsIdentity_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISettingsItem_Impl: Sized { fn GetName(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn GetValue(&self) -> ::windows_core::Result; - fn SetValue(&self, value: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetSettingType(&self) -> ::windows_core::Result; fn GetDataType(&self) -> ::windows_core::Result; fn GetValueRaw(&self, data: *mut *mut u8, datasize: *mut u32) -> ::windows_core::Result<()>; @@ -385,18 +379,16 @@ pub trait ISettingsItem_Impl: Sized { fn CreateSettingByPath(&self, path: &::windows_core::PCWSTR) -> ::windows_core::Result; fn RemoveSettingByPath(&self, path: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetListKeyInformation(&self, keyname: *mut ::windows_core::BSTR, datatype: *mut WcmDataType) -> ::windows_core::Result<()>; - fn CreateListElement(&self, keydata: *const super::Variant::VARIANT) -> ::windows_core::Result; + fn CreateListElement(&self, keydata: *const ::windows_core::VARIANT) -> ::windows_core::Result; fn RemoveListElement(&self, elementname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn Attributes(&self) -> ::windows_core::Result; - fn GetAttribute(&self, name: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetAttribute(&self, name: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetRestrictionFacets(&self) -> ::windows_core::Result; - fn GetRestriction(&self, restrictionfacet: WcmRestrictionFacets) -> ::windows_core::Result; - fn GetKeyValue(&self) -> ::windows_core::Result; + fn GetRestriction(&self, restrictionfacet: WcmRestrictionFacets) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetKeyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISettingsItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISettingsItem_Vtbl { pub const fn new, Impl: ISettingsItem_Impl, const OFFSET: isize>() -> ISettingsItem_Vtbl { unsafe extern "system" fn GetName, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -410,7 +402,7 @@ impl ISettingsItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -421,7 +413,7 @@ impl ISettingsItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&value)).into() @@ -523,7 +515,7 @@ impl ISettingsItem_Vtbl { let this = (*this).get_impl(); this.GetListKeyInformation(::core::mem::transmute_copy(&keyname), ::core::mem::transmute_copy(&datatype)).into() } - unsafe extern "system" fn CreateListElement, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, keydata: *const super::Variant::VARIANT, child: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateListElement, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, keydata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, child: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateListElement(::core::mem::transmute_copy(&keydata)) { @@ -550,7 +542,7 @@ impl ISettingsItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetAttribute, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttribute, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttribute(::core::mem::transmute(&name)) { @@ -583,7 +575,7 @@ impl ISettingsItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRestriction, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, restrictionfacet: WcmRestrictionFacets, facetdata: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRestriction, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, restrictionfacet: WcmRestrictionFacets, facetdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRestriction(::core::mem::transmute_copy(&restrictionfacet)) { @@ -594,7 +586,7 @@ impl ISettingsItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetKeyValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetKeyValue, Impl: ISettingsItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetKeyValue() { @@ -635,8 +627,6 @@ impl ISettingsItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ISettingsNamespace_Impl: Sized { fn GetIdentity(&self) -> ::windows_core::Result; fn Settings(&self) -> ::windows_core::Result; @@ -644,11 +634,9 @@ pub trait ISettingsNamespace_Impl: Sized { fn GetSettingByPath(&self, path: &::windows_core::PCWSTR) -> ::windows_core::Result; fn CreateSettingByPath(&self, path: &::windows_core::PCWSTR) -> ::windows_core::Result; fn RemoveSettingByPath(&self, path: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn GetAttribute(&self, name: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetAttribute(&self, name: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISettingsNamespace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ISettingsNamespace_Vtbl { pub const fn new, Impl: ISettingsNamespace_Impl, const OFFSET: isize>() -> ISettingsNamespace_Vtbl { unsafe extern "system" fn GetIdentity, Impl: ISettingsNamespace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, settingsid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -711,7 +699,7 @@ impl ISettingsNamespace_Vtbl { let this = (*this).get_impl(); this.RemoveSettingByPath(::core::mem::transmute(&path)).into() } - unsafe extern "system" fn GetAttribute, Impl: ISettingsNamespace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttribute, Impl: ISettingsNamespace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttribute(::core::mem::transmute(&name)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/mod.rs b/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/mod.rs index 3317dd6b04..9a11185c25 100644 --- a/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/SettingsManagementInfrastructure/mod.rs @@ -1,9 +1,7 @@ ::windows_core::imp::com_interface!(IItemEnumerator, IItemEnumerator_Vtbl, 0x9f7d7bb7_20b3_11da_81a5_0030f1642e3c); ::windows_core::imp::interface_hierarchy!(IItemEnumerator, ::windows_core::IUnknown); impl IItemEnumerator { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Current(&self) -> ::windows_core::Result { + pub unsafe fn Current(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Current)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -19,10 +17,7 @@ impl IItemEnumerator { #[doc(hidden)] pub struct IItemEnumerator_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Current: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Current: usize, + pub Current: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, item: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MoveNext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itemvalid: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -122,9 +117,9 @@ impl ISettingsEngine { pub unsafe fn UnloadStore(&self, reserved: *const ::core::ffi::c_void) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).UnloadStore)(::windows_core::Interface::as_raw(self), reserved).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterNamespace(&self, settingsid: P0, stream: P1, pushsettings: P2) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RegisterNamespace(&self, settingsid: P0, stream: P1, pushsettings: P2) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, @@ -186,9 +181,9 @@ pub struct ISettingsEngine_Vtbl { pub GetStoreStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reserved: *const ::core::ffi::c_void, status: *mut WcmUserStatus) -> ::windows_core::HRESULT, pub LoadStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: u32) -> ::windows_core::HRESULT, pub UnloadStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reserved: *const ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterNamespace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, settingsid: *mut ::core::ffi::c_void, stream: *mut ::core::ffi::c_void, pushsettings: super::super::Foundation::BOOL, results: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RegisterNamespace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, settingsid: *mut ::core::ffi::c_void, stream: *mut ::core::ffi::c_void, pushsettings: super::super::Foundation::BOOL, results: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RegisterNamespace: usize, pub UnregisterNamespace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, settingsid: *mut ::core::ffi::c_void, removesettings: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub CreateTargetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, target: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -240,16 +235,12 @@ impl ISettingsItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, value: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), value).ok() + pub unsafe fn SetValue(&self, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value)).ok() } pub unsafe fn GetSettingType(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -303,11 +294,9 @@ impl ISettingsItem { pub unsafe fn GetListKeyInformation(&self, keyname: *mut ::windows_core::BSTR, datatype: *mut WcmDataType) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetListKeyInformation)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(keyname), datatype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateListElement(&self, keydata: *const super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreateListElement(&self, keydata: *const ::windows_core::VARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateListElement)(::windows_core::Interface::as_raw(self), keydata, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateListElement)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(keydata), &mut result__).from_abi(result__) } pub unsafe fn RemoveListElement(&self, elementname: P0) -> ::windows_core::Result<()> where @@ -319,9 +308,7 @@ impl ISettingsItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Attributes)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttribute(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetAttribute(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -336,15 +323,11 @@ impl ISettingsItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRestrictionFacets)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRestriction(&self, restrictionfacet: WcmRestrictionFacets) -> ::windows_core::Result { + pub unsafe fn GetRestriction(&self, restrictionfacet: WcmRestrictionFacets) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRestriction)(::windows_core::Interface::as_raw(self), restrictionfacet, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetKeyValue(&self) -> ::windows_core::Result { + pub unsafe fn GetKeyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetKeyValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -354,14 +337,8 @@ impl ISettingsItem { pub struct ISettingsItem_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetSettingType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut WcmSettingType) -> ::windows_core::HRESULT, pub GetDataType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: *mut WcmDataType) -> ::windows_core::HRESULT, pub GetValueRaw: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: *mut *mut u8, datasize: *mut u32) -> ::windows_core::HRESULT, @@ -373,26 +350,14 @@ pub struct ISettingsItem_Vtbl { pub CreateSettingByPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::windows_core::PCWSTR, setting: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RemoveSettingByPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub GetListKeyInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, keyname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, datatype: *mut WcmDataType) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateListElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, keydata: *const super::Variant::VARIANT, child: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreateListElement: usize, + pub CreateListElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, keydata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, child: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RemoveListElement: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, elementname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub Attributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttribute: usize, + pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub GetRestrictionFacets: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, restrictionfacets: *mut WcmRestrictionFacets) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRestriction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, restrictionfacet: WcmRestrictionFacets, facetdata: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetRestriction: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetKeyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetKeyValue: usize, + pub GetRestriction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, restrictionfacet: WcmRestrictionFacets, facetdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetKeyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ISettingsNamespace, ISettingsNamespace_Vtbl, 0x9f7d7bba_20b3_11da_81a5_0030f1642e3c); ::windows_core::imp::interface_hierarchy!(ISettingsNamespace, ::windows_core::IUnknown); @@ -432,9 +397,7 @@ impl ISettingsNamespace { { (::windows_core::Interface::vtable(self).RemoveSettingByPath)(::windows_core::Interface::as_raw(self), path.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttribute(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetAttribute(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -452,10 +415,7 @@ pub struct ISettingsNamespace_Vtbl { pub GetSettingByPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::windows_core::PCWSTR, setting: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateSettingByPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::windows_core::PCWSTR, setting: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RemoveSettingByPath: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttribute: usize, + pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::windows_core::PCWSTR, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ISettingsResult, ISettingsResult_Vtbl, 0x9f7d7bbc_20b3_11da_81a5_0030f1642e3c); ::windows_core::imp::interface_hierarchy!(ISettingsResult, ::windows_core::IUnknown); diff --git a/crates/libs/windows/src/Windows/Win32/System/SideShow/impl.rs b/crates/libs/windows/src/Windows/Win32/System/SideShow/impl.rs index 52cca5baec..1d2ae6ef4a 100644 --- a/crates/libs/windows/src/Windows/Win32/System/SideShow/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/SideShow/impl.rs @@ -1,11 +1,11 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ISideShowBulkCapabilities_Impl: Sized + ISideShowCapabilities_Impl { fn GetCapabilities(&self, in_keycollection: ::core::option::Option<&ISideShowKeyCollection>, inout_pvalues: *mut ::core::option::Option) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ISideShowBulkCapabilities {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ISideShowBulkCapabilities_Vtbl { pub const fn new, Impl: ISideShowBulkCapabilities_Impl, const OFFSET: isize>() -> ISideShowBulkCapabilities_Vtbl { unsafe extern "system" fn GetCapabilities, Impl: ISideShowBulkCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, in_keycollection: *mut ::core::ffi::c_void, inout_pvalues: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -19,17 +19,17 @@ impl ISideShowBulkCapabilities_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ISideShowCapabilities_Impl: Sized { - fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ISideShowCapabilities {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ISideShowCapabilities_Vtbl { pub const fn new, Impl: ISideShowCapabilities_Impl, const OFFSET: isize>() -> ISideShowCapabilities_Vtbl { - unsafe extern "system" fn GetCapability, Impl: ISideShowCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCapability, Impl: ISideShowCapabilities_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetCapability(::core::mem::transmute_copy(&in_keycapability), ::core::mem::transmute_copy(&inout_pvalue)).into() @@ -429,21 +429,17 @@ impl ISideShowNotificationManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait ISideShowPropVariantCollection_Impl: Sized { - fn Add(&self, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn Add(&self, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; - fn GetAt(&self, dwindex: u32, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetAt(&self, dwindex: u32, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetCount(&self, pcelems: *const u32) -> ::windows_core::Result<()>; fn RemoveAt(&self, dwindex: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ISideShowPropVariantCollection {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ISideShowPropVariantCollection_Vtbl { pub const fn new, Impl: ISideShowPropVariantCollection_Impl, const OFFSET: isize>() -> ISideShowPropVariantCollection_Vtbl { - unsafe extern "system" fn Add, Impl: ISideShowPropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: ISideShowPropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Add(::core::mem::transmute_copy(&pvalue)).into() @@ -453,7 +449,7 @@ impl ISideShowPropVariantCollection_Vtbl { let this = (*this).get_impl(); this.Clear().into() } - unsafe extern "system" fn GetAt, Impl: ISideShowPropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAt, Impl: ISideShowPropVariantCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetAt(::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&pvalue)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/SideShow/mod.rs b/crates/libs/windows/src/Windows/Win32/System/SideShow/mod.rs index 3fc9a58c84..9cb9be255f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/SideShow/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/SideShow/mod.rs @@ -1,10 +1,10 @@ ::windows_core::imp::com_interface!(ISideShowBulkCapabilities, ISideShowBulkCapabilities_Vtbl, 0x3a2b7fbc_3ad5_48bd_bbf1_0e6cfbd10807); ::windows_core::imp::interface_hierarchy!(ISideShowBulkCapabilities, ::windows_core::IUnknown, ISideShowCapabilities); impl ISideShowBulkCapabilities { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetCapability)(::windows_core::Interface::as_raw(self), in_keycapability, inout_pvalue).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetCapability)(::windows_core::Interface::as_raw(self), in_keycapability, ::core::mem::transmute(inout_pvalue)).ok() } pub unsafe fn GetCapabilities(&self, in_keycollection: P0, inout_pvalues: *mut ::core::option::Option) -> ::windows_core::Result<()> where @@ -22,19 +22,19 @@ pub struct ISideShowBulkCapabilities_Vtbl { ::windows_core::imp::com_interface!(ISideShowCapabilities, ISideShowCapabilities_Vtbl, 0x535e1379_c09e_4a54_a511_597bab3a72b8); ::windows_core::imp::interface_hierarchy!(ISideShowCapabilities, ::windows_core::IUnknown); impl ISideShowCapabilities { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetCapability)(::windows_core::Interface::as_raw(self), in_keycapability, inout_pvalue).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetCapability(&self, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetCapability)(::windows_core::Interface::as_raw(self), in_keycapability, ::core::mem::transmute(inout_pvalue)).ok() } } #[repr(C)] #[doc(hidden)] pub struct ISideShowCapabilities_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetCapability: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetCapability: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, in_keycapability: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, inout_pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetCapability: usize, } ::windows_core::imp::com_interface!(ISideShowCapabilitiesCollection, ISideShowCapabilitiesCollection_Vtbl, 0x50305597_5e0d_4ff7_b3af_33d0d9bd52dd); @@ -292,18 +292,14 @@ pub struct ISideShowNotificationManager_Vtbl { ::windows_core::imp::com_interface!(ISideShowPropVariantCollection, ISideShowPropVariantCollection_Vtbl, 0x2ea7a549_7bff_4aae_bab0_22d43111de49); ::windows_core::imp::interface_hierarchy!(ISideShowPropVariantCollection, ::windows_core::IUnknown); impl ISideShowPropVariantCollection { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), pvalue).ok() + pub unsafe fn Add(&self, pvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetAt(&self, dwindex: u32, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), dwindex, pvalue).ok() + pub unsafe fn GetAt(&self, dwindex: u32, pvalue: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), dwindex, ::core::mem::transmute(pvalue)).ok() } pub unsafe fn GetCount(&self, pcelems: *const u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetCount)(::windows_core::Interface::as_raw(self), pcelems).ok() @@ -316,15 +312,9 @@ impl ISideShowPropVariantCollection { #[doc(hidden)] pub struct ISideShowPropVariantCollection_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - Add: usize, + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *mut super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetAt: usize, + pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcelems: *const u32) -> ::windows_core::HRESULT, pub RemoveAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32) -> ::windows_core::HRESULT, } diff --git a/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/impl.rs b/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/impl.rs index aaf0dbba7a..18e5031902 100644 --- a/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/impl.rs @@ -1,13 +1,13 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAction_Impl: Sized + super::Com::IDispatch_Impl { fn Id(&self, pid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetId(&self, id: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Type(&self, ptype: *mut TASK_ACTION_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAction_Vtbl { pub const fn new, Impl: IAction_Impl, const OFFSET: isize>() -> IAction_Vtbl { unsafe extern "system" fn Id, Impl: IAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -36,8 +36,8 @@ impl IAction_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IActionCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self, pcount: *mut i32) -> ::windows_core::Result<()>; fn get_Item(&self, index: i32) -> ::windows_core::Result; @@ -45,14 +45,14 @@ pub trait IActionCollection_Impl: Sized + super::Com::IDispatch_Impl { fn XmlText(&self, ptext: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetXmlText(&self, text: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Create(&self, r#type: TASK_ACTION_TYPE) -> ::windows_core::Result; - fn Remove(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn Context(&self, pcontext: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetContext(&self, context: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IActionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IActionCollection_Vtbl { pub const fn new, Impl: IActionCollection_Impl, const OFFSET: isize>() -> IActionCollection_Vtbl { unsafe extern "system" fn Count, Impl: IActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -103,7 +103,7 @@ impl IActionCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IActionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -141,15 +141,15 @@ impl IActionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IBootTrigger_Impl: Sized + ITrigger_Impl { fn Delay(&self, pdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDelay(&self, delay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IBootTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IBootTrigger_Vtbl { pub const fn new, Impl: IBootTrigger_Impl, const OFFSET: isize>() -> IBootTrigger_Vtbl { unsafe extern "system" fn Delay, Impl: IBootTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -168,17 +168,17 @@ impl IBootTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IComHandlerAction_Impl: Sized + IAction_Impl { fn ClassId(&self, pclsid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetClassId(&self, clsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Data(&self, pdata: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetData(&self, data: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IComHandlerAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IComHandlerAction_Vtbl { pub const fn new, Impl: IComHandlerAction_Impl, const OFFSET: isize>() -> IComHandlerAction_Vtbl { unsafe extern "system" fn ClassId, Impl: IComHandlerAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pclsid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -213,17 +213,17 @@ impl IComHandlerAction_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDailyTrigger_Impl: Sized + ITrigger_Impl { fn DaysInterval(&self, pdays: *mut i16) -> ::windows_core::Result<()>; fn SetDaysInterval(&self, days: i16) -> ::windows_core::Result<()>; fn RandomDelay(&self, prandomdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetRandomDelay(&self, randomdelay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDailyTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDailyTrigger_Vtbl { pub const fn new, Impl: IDailyTrigger_Impl, const OFFSET: isize>() -> IDailyTrigger_Vtbl { unsafe extern "system" fn DaysInterval, Impl: IDailyTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdays: *mut i16) -> ::windows_core::HRESULT { @@ -258,8 +258,8 @@ impl IDailyTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEmailAction_Impl: Sized + IAction_Impl { fn Server(&self, pserver: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetServer(&self, server: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -282,9 +282,9 @@ pub trait IEmailAction_Impl: Sized + IAction_Impl { fn Attachments(&self, pattachements: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn SetAttachments(&self, pattachements: *mut super::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEmailAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEmailAction_Vtbl { pub const fn new, Impl: IEmailAction_Impl, const OFFSET: isize>() -> IEmailAction_Vtbl { unsafe extern "system" fn Server, Impl: IEmailAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pserver: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -468,8 +468,8 @@ impl IEnumWorkItems_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IEventTrigger_Impl: Sized + ITrigger_Impl { fn Subscription(&self, pquery: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSubscription(&self, query: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -478,9 +478,9 @@ pub trait IEventTrigger_Impl: Sized + ITrigger_Impl { fn ValueQueries(&self) -> ::windows_core::Result; fn SetValueQueries(&self, pnamedxpaths: ::core::option::Option<&ITaskNamedValueCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IEventTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IEventTrigger_Vtbl { pub const fn new, Impl: IEventTrigger_Impl, const OFFSET: isize>() -> IEventTrigger_Vtbl { unsafe extern "system" fn Subscription, Impl: IEventTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pquery: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -533,8 +533,8 @@ impl IEventTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IExecAction_Impl: Sized + IAction_Impl { fn Path(&self, ppath: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetPath(&self, path: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -543,9 +543,9 @@ pub trait IExecAction_Impl: Sized + IAction_Impl { fn WorkingDirectory(&self, pworkingdirectory: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetWorkingDirectory(&self, workingdirectory: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IExecAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IExecAction_Vtbl { pub const fn new, Impl: IExecAction_Impl, const OFFSET: isize>() -> IExecAction_Vtbl { unsafe extern "system" fn Path, Impl: IExecAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -592,15 +592,15 @@ impl IExecAction_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IExecAction2_Impl: Sized + IExecAction_Impl { fn HideAppWindow(&self, phideappwindow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetHideAppWindow(&self, hideappwindow: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IExecAction2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IExecAction2_Vtbl { pub const fn new, Impl: IExecAction2_Impl, const OFFSET: isize>() -> IExecAction2_Vtbl { unsafe extern "system" fn HideAppWindow, Impl: IExecAction2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, phideappwindow: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -623,8 +623,8 @@ impl IExecAction2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIdleSettings_Impl: Sized + super::Com::IDispatch_Impl { fn IdleDuration(&self, pdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetIdleDuration(&self, delay: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -635,9 +635,9 @@ pub trait IIdleSettings_Impl: Sized + super::Com::IDispatch_Impl { fn RestartOnIdle(&self, prestart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetRestartOnIdle(&self, restart: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIdleSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIdleSettings_Vtbl { pub const fn new, Impl: IIdleSettings_Impl, const OFFSET: isize>() -> IIdleSettings_Vtbl { unsafe extern "system" fn IdleDuration, Impl: IIdleSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -696,12 +696,12 @@ impl IIdleSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIdleTrigger_Impl: Sized + ITrigger_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIdleTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIdleTrigger_Vtbl { pub const fn new, Impl: IIdleTrigger_Impl, const OFFSET: isize>() -> IIdleTrigger_Vtbl { Self { base__: ITrigger_Vtbl::new::() } @@ -710,17 +710,17 @@ impl IIdleTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILogonTrigger_Impl: Sized + ITrigger_Impl { fn Delay(&self, pdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDelay(&self, delay: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn UserId(&self, puser: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetUserId(&self, user: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILogonTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILogonTrigger_Vtbl { pub const fn new, Impl: ILogonTrigger_Impl, const OFFSET: isize>() -> ILogonTrigger_Vtbl { unsafe extern "system" fn Delay, Impl: ILogonTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -755,8 +755,8 @@ impl ILogonTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMaintenanceSettings_Impl: Sized + super::Com::IDispatch_Impl { fn SetPeriod(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Period(&self, target: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -765,9 +765,9 @@ pub trait IMaintenanceSettings_Impl: Sized + super::Com::IDispatch_Impl { fn SetExclusive(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn Exclusive(&self, target: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMaintenanceSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMaintenanceSettings_Vtbl { pub const fn new, Impl: IMaintenanceSettings_Impl, const OFFSET: isize>() -> IMaintenanceSettings_Vtbl { unsafe extern "system" fn SetPeriod, Impl: IMaintenanceSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -814,8 +814,8 @@ impl IMaintenanceSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMonthlyDOWTrigger_Impl: Sized + ITrigger_Impl { fn DaysOfWeek(&self, pdays: *mut i16) -> ::windows_core::Result<()>; fn SetDaysOfWeek(&self, days: i16) -> ::windows_core::Result<()>; @@ -828,9 +828,9 @@ pub trait IMonthlyDOWTrigger_Impl: Sized + ITrigger_Impl { fn RandomDelay(&self, prandomdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetRandomDelay(&self, randomdelay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMonthlyDOWTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMonthlyDOWTrigger_Vtbl { pub const fn new, Impl: IMonthlyDOWTrigger_Impl, const OFFSET: isize>() -> IMonthlyDOWTrigger_Vtbl { unsafe extern "system" fn DaysOfWeek, Impl: IMonthlyDOWTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdays: *mut i16) -> ::windows_core::HRESULT { @@ -901,8 +901,8 @@ impl IMonthlyDOWTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMonthlyTrigger_Impl: Sized + ITrigger_Impl { fn DaysOfMonth(&self, pdays: *mut i32) -> ::windows_core::Result<()>; fn SetDaysOfMonth(&self, days: i32) -> ::windows_core::Result<()>; @@ -913,9 +913,9 @@ pub trait IMonthlyTrigger_Impl: Sized + ITrigger_Impl { fn RandomDelay(&self, prandomdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetRandomDelay(&self, randomdelay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMonthlyTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMonthlyTrigger_Vtbl { pub const fn new, Impl: IMonthlyTrigger_Impl, const OFFSET: isize>() -> IMonthlyTrigger_Vtbl { unsafe extern "system" fn DaysOfMonth, Impl: IMonthlyTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdays: *mut i32) -> ::windows_core::HRESULT { @@ -974,17 +974,17 @@ impl IMonthlyTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INetworkSettings_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self, pname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Id(&self, pid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetId(&self, id: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INetworkSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INetworkSettings_Vtbl { pub const fn new, Impl: INetworkSettings_Impl, const OFFSET: isize>() -> INetworkSettings_Vtbl { unsafe extern "system" fn Name, Impl: INetworkSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1019,8 +1019,8 @@ impl INetworkSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrincipal_Impl: Sized + super::Com::IDispatch_Impl { fn Id(&self, pid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetId(&self, id: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1035,9 +1035,9 @@ pub trait IPrincipal_Impl: Sized + super::Com::IDispatch_Impl { fn RunLevel(&self, prunlevel: *mut TASK_RUNLEVEL_TYPE) -> ::windows_core::Result<()>; fn SetRunLevel(&self, runlevel: TASK_RUNLEVEL_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrincipal {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrincipal_Vtbl { pub const fn new, Impl: IPrincipal_Impl, const OFFSET: isize>() -> IPrincipal_Vtbl { unsafe extern "system" fn Id, Impl: IPrincipal_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1120,8 +1120,8 @@ impl IPrincipal_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPrincipal2_Impl: Sized + super::Com::IDispatch_Impl { fn ProcessTokenSidType(&self, pprocesstokensidtype: *mut TASK_PROCESSTOKENSID_TYPE) -> ::windows_core::Result<()>; fn SetProcessTokenSidType(&self, processtokensidtype: TASK_PROCESSTOKENSID_TYPE) -> ::windows_core::Result<()>; @@ -1129,9 +1129,9 @@ pub trait IPrincipal2_Impl: Sized + super::Com::IDispatch_Impl { fn get_RequiredPrivilege(&self, index: i32, pprivilege: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddRequiredPrivilege(&self, privilege: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPrincipal2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPrincipal2_Vtbl { pub const fn new, Impl: IPrincipal2_Impl, const OFFSET: isize>() -> IPrincipal2_Vtbl { unsafe extern "system" fn ProcessTokenSidType, Impl: IPrincipal2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprocesstokensidtype: *mut TASK_PROCESSTOKENSID_TYPE) -> ::windows_core::HRESULT { @@ -1199,16 +1199,16 @@ impl IProvideTaskPage_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRegisteredTask_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn State(&self) -> ::windows_core::Result; fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn Run(&self, params: &super::Variant::VARIANT) -> ::windows_core::Result; - fn RunEx(&self, params: &super::Variant::VARIANT, flags: i32, sessionid: i32, user: &::windows_core::BSTR) -> ::windows_core::Result; + fn Run(&self, params: &::windows_core::VARIANT) -> ::windows_core::Result; + fn RunEx(&self, params: &::windows_core::VARIANT, flags: i32, sessionid: i32, user: &::windows_core::BSTR) -> ::windows_core::Result; fn GetInstances(&self, flags: i32) -> ::windows_core::Result; fn LastRunTime(&self) -> ::windows_core::Result; fn LastTaskResult(&self) -> ::windows_core::Result; @@ -1221,9 +1221,9 @@ pub trait IRegisteredTask_Impl: Sized + super::Com::IDispatch_Impl { fn Stop(&self, flags: i32) -> ::windows_core::Result<()>; fn GetRunTimes(&self, pststart: *const super::super::Foundation::SYSTEMTIME, pstend: *const super::super::Foundation::SYSTEMTIME, pcount: *mut u32, pruntimes: *mut *mut super::super::Foundation::SYSTEMTIME) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRegisteredTask {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRegisteredTask_Vtbl { pub const fn new, Impl: IRegisteredTask_Impl, const OFFSET: isize>() -> IRegisteredTask_Vtbl { unsafe extern "system" fn Name, Impl: IRegisteredTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1275,7 +1275,7 @@ impl IRegisteredTask_Vtbl { let this = (*this).get_impl(); this.SetEnabled(::core::mem::transmute_copy(&enabled)).into() } - unsafe extern "system" fn Run, Impl: IRegisteredTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, params: super::Variant::VARIANT, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Run, Impl: IRegisteredTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, params: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Run(::core::mem::transmute(¶ms)) { @@ -1286,7 +1286,7 @@ impl IRegisteredTask_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RunEx, Impl: IRegisteredTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, params: super::Variant::VARIANT, flags: i32, sessionid: i32, user: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RunEx, Impl: IRegisteredTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, params: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, sessionid: i32, user: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RunEx(::core::mem::transmute(¶ms), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&sessionid), ::core::mem::transmute(&user)) { @@ -1426,16 +1426,16 @@ impl IRegisteredTask_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRegisteredTaskCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRegisteredTaskCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRegisteredTaskCollection_Vtbl { pub const fn new, Impl: IRegisteredTaskCollection_Impl, const OFFSET: isize>() -> IRegisteredTaskCollection_Vtbl { unsafe extern "system" fn Count, Impl: IRegisteredTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -1449,7 +1449,7 @@ impl IRegisteredTaskCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IRegisteredTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppregisteredtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IRegisteredTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppregisteredtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -1482,8 +1482,8 @@ impl IRegisteredTaskCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRegistrationInfo_Impl: Sized + super::Com::IDispatch_Impl { fn Description(&self, pdescription: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDescription(&self, description: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1499,14 +1499,14 @@ pub trait IRegistrationInfo_Impl: Sized + super::Com::IDispatch_Impl { fn SetXmlText(&self, text: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn URI(&self, puri: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetURI(&self, uri: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SecurityDescriptor(&self, psddl: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SetSecurityDescriptor(&self, sddl: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SecurityDescriptor(&self, psddl: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SetSecurityDescriptor(&self, sddl: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Source(&self, psource: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetSource(&self, source: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRegistrationInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRegistrationInfo_Vtbl { pub const fn new, Impl: IRegistrationInfo_Impl, const OFFSET: isize>() -> IRegistrationInfo_Vtbl { unsafe extern "system" fn Description, Impl: IRegistrationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1579,12 +1579,12 @@ impl IRegistrationInfo_Vtbl { let this = (*this).get_impl(); this.SetURI(::core::mem::transmute(&uri)).into() } - unsafe extern "system" fn SecurityDescriptor, Impl: IRegistrationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psddl: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SecurityDescriptor, Impl: IRegistrationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psddl: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SecurityDescriptor(::core::mem::transmute_copy(&psddl)).into() } - unsafe extern "system" fn SetSecurityDescriptor, Impl: IRegistrationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sddl: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSecurityDescriptor, Impl: IRegistrationInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSecurityDescriptor(::core::mem::transmute(&sddl)).into() @@ -1625,15 +1625,15 @@ impl IRegistrationInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRegistrationTrigger_Impl: Sized + ITrigger_Impl { fn Delay(&self, pdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDelay(&self, delay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRegistrationTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRegistrationTrigger_Vtbl { pub const fn new, Impl: IRegistrationTrigger_Impl, const OFFSET: isize>() -> IRegistrationTrigger_Vtbl { unsafe extern "system" fn Delay, Impl: IRegistrationTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1652,8 +1652,8 @@ impl IRegistrationTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRepetitionPattern_Impl: Sized + super::Com::IDispatch_Impl { fn Interval(&self, pinterval: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetInterval(&self, interval: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1662,9 +1662,9 @@ pub trait IRepetitionPattern_Impl: Sized + super::Com::IDispatch_Impl { fn StopAtDurationEnd(&self, pstop: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetStopAtDurationEnd(&self, stop: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRepetitionPattern {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRepetitionPattern_Vtbl { pub const fn new, Impl: IRepetitionPattern_Impl, const OFFSET: isize>() -> IRepetitionPattern_Vtbl { unsafe extern "system" fn Interval, Impl: IRepetitionPattern_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pinterval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1711,8 +1711,8 @@ impl IRepetitionPattern_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRunningTask_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn InstanceGuid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1723,9 +1723,9 @@ pub trait IRunningTask_Impl: Sized + super::Com::IDispatch_Impl { fn Refresh(&self) -> ::windows_core::Result<()>; fn EnginePID(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRunningTask {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRunningTask_Vtbl { pub const fn new, Impl: IRunningTask_Impl, const OFFSET: isize>() -> IRunningTask_Vtbl { unsafe extern "system" fn Name, Impl: IRunningTask_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1820,16 +1820,16 @@ impl IRunningTask_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRunningTaskCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRunningTaskCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRunningTaskCollection_Vtbl { pub const fn new, Impl: IRunningTaskCollection_Impl, const OFFSET: isize>() -> IRunningTaskCollection_Vtbl { unsafe extern "system" fn Count, Impl: IRunningTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -1843,7 +1843,7 @@ impl IRunningTaskCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: IRunningTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: IRunningTaskCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2164,8 +2164,8 @@ impl IScheduledWorkItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISessionStateChangeTrigger_Impl: Sized + ITrigger_Impl { fn Delay(&self, pdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetDelay(&self, delay: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2174,9 +2174,9 @@ pub trait ISessionStateChangeTrigger_Impl: Sized + ITrigger_Impl { fn StateChange(&self, ptype: *mut TASK_SESSION_STATE_CHANGE_TYPE) -> ::windows_core::Result<()>; fn SetStateChange(&self, r#type: TASK_SESSION_STATE_CHANGE_TYPE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISessionStateChangeTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISessionStateChangeTrigger_Vtbl { pub const fn new, Impl: ISessionStateChangeTrigger_Impl, const OFFSET: isize>() -> ISessionStateChangeTrigger_Vtbl { unsafe extern "system" fn Delay, Impl: ISessionStateChangeTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2223,17 +2223,17 @@ impl ISessionStateChangeTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShowMessageAction_Impl: Sized + IAction_Impl { fn Title(&self, ptitle: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetTitle(&self, title: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn MessageBody(&self, pmessagebody: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetMessageBody(&self, messagebody: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShowMessageAction {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShowMessageAction_Vtbl { pub const fn new, Impl: IShowMessageAction_Impl, const OFFSET: isize>() -> IShowMessageAction_Vtbl { unsafe extern "system" fn Title, Impl: IShowMessageAction_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptitle: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2401,8 +2401,8 @@ impl ITask_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskDefinition_Impl: Sized + super::Com::IDispatch_Impl { fn RegistrationInfo(&self) -> ::windows_core::Result; fn SetRegistrationInfo(&self, pregistrationinfo: ::core::option::Option<&IRegistrationInfo>) -> ::windows_core::Result<()>; @@ -2419,9 +2419,9 @@ pub trait ITaskDefinition_Impl: Sized + super::Com::IDispatch_Impl { fn XmlText(&self, pxml: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetXmlText(&self, xml: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskDefinition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskDefinition_Vtbl { pub const fn new, Impl: ITaskDefinition_Impl, const OFFSET: isize>() -> ITaskDefinition_Vtbl { unsafe extern "system" fn RegistrationInfo, Impl: ITaskDefinition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppregistrationinfo: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2546,26 +2546,26 @@ impl ITaskDefinition_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskFolder_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetFolder(&self, path: &::windows_core::BSTR) -> ::windows_core::Result; fn GetFolders(&self, flags: i32) -> ::windows_core::Result; - fn CreateFolder(&self, subfoldername: &::windows_core::BSTR, sddl: &super::Variant::VARIANT) -> ::windows_core::Result; + fn CreateFolder(&self, subfoldername: &::windows_core::BSTR, sddl: &::windows_core::VARIANT) -> ::windows_core::Result; fn DeleteFolder(&self, subfoldername: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<()>; fn GetTask(&self, path: &::windows_core::BSTR) -> ::windows_core::Result; fn GetTasks(&self, flags: i32) -> ::windows_core::Result; fn DeleteTask(&self, name: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<()>; - fn RegisterTask(&self, path: &::windows_core::BSTR, xmltext: &::windows_core::BSTR, flags: i32, userid: &super::Variant::VARIANT, password: &super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: &super::Variant::VARIANT) -> ::windows_core::Result; - fn RegisterTaskDefinition(&self, path: &::windows_core::BSTR, pdefinition: ::core::option::Option<&ITaskDefinition>, flags: i32, userid: &super::Variant::VARIANT, password: &super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: &super::Variant::VARIANT) -> ::windows_core::Result; + fn RegisterTask(&self, path: &::windows_core::BSTR, xmltext: &::windows_core::BSTR, flags: i32, userid: &::windows_core::VARIANT, password: &::windows_core::VARIANT, logontype: TASK_LOGON_TYPE, sddl: &::windows_core::VARIANT) -> ::windows_core::Result; + fn RegisterTaskDefinition(&self, path: &::windows_core::BSTR, pdefinition: ::core::option::Option<&ITaskDefinition>, flags: i32, userid: &::windows_core::VARIANT, password: &::windows_core::VARIANT, logontype: TASK_LOGON_TYPE, sddl: &::windows_core::VARIANT) -> ::windows_core::Result; fn GetSecurityDescriptor(&self, securityinformation: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn SetSecurityDescriptor(&self, sddl: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskFolder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskFolder_Vtbl { pub const fn new, Impl: ITaskFolder_Impl, const OFFSET: isize>() -> ITaskFolder_Vtbl { unsafe extern "system" fn Name, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2612,7 +2612,7 @@ impl ITaskFolder_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreateFolder, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, subfoldername: ::std::mem::MaybeUninit<::windows_core::BSTR>, sddl: super::Variant::VARIANT, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateFolder, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, subfoldername: ::std::mem::MaybeUninit<::windows_core::BSTR>, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateFolder(::core::mem::transmute(&subfoldername), ::core::mem::transmute(&sddl)) { @@ -2655,7 +2655,7 @@ impl ITaskFolder_Vtbl { let this = (*this).get_impl(); this.DeleteTask(::core::mem::transmute(&name), ::core::mem::transmute_copy(&flags)).into() } - unsafe extern "system" fn RegisterTask, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, xmltext: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterTask, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, xmltext: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, userid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>, logontype: TASK_LOGON_TYPE, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RegisterTask(::core::mem::transmute(&path), ::core::mem::transmute(&xmltext), ::core::mem::transmute_copy(&flags), ::core::mem::transmute(&userid), ::core::mem::transmute(&password), ::core::mem::transmute_copy(&logontype), ::core::mem::transmute(&sddl)) { @@ -2666,7 +2666,7 @@ impl ITaskFolder_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RegisterTaskDefinition, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdefinition: *mut ::core::ffi::c_void, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterTaskDefinition, Impl: ITaskFolder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdefinition: *mut ::core::ffi::c_void, flags: i32, userid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>, logontype: TASK_LOGON_TYPE, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RegisterTaskDefinition(::core::mem::transmute(&path), ::windows_core::from_raw_borrowed(&pdefinition), ::core::mem::transmute_copy(&flags), ::core::mem::transmute(&userid), ::core::mem::transmute(&password), ::core::mem::transmute_copy(&logontype), ::core::mem::transmute(&sddl)) { @@ -2714,16 +2714,16 @@ impl ITaskFolder_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskFolderCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn get_Item(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result; + fn get_Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskFolderCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskFolderCollection_Vtbl { pub const fn new, Impl: ITaskFolderCollection_Impl, const OFFSET: isize>() -> ITaskFolderCollection_Vtbl { unsafe extern "system" fn Count, Impl: ITaskFolderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -2737,7 +2737,7 @@ impl ITaskFolderCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_Item, Impl: ITaskFolderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Item, Impl: ITaskFolderCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Item(::core::mem::transmute(&index)) { @@ -2844,8 +2844,8 @@ impl ITaskHandlerStatus_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskNamedValueCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self, pcount: *mut i32) -> ::windows_core::Result<()>; fn get_Item(&self, index: i32) -> ::windows_core::Result; @@ -2854,9 +2854,9 @@ pub trait ITaskNamedValueCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Remove(&self, index: i32) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskNamedValueCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskNamedValueCollection_Vtbl { pub const fn new, Impl: ITaskNamedValueCollection_Impl, const OFFSET: isize>() -> ITaskNamedValueCollection_Vtbl { unsafe extern "system" fn Count, Impl: ITaskNamedValueCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -2921,17 +2921,17 @@ impl ITaskNamedValueCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskNamedValuePair_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self, pname: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetName(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Value(&self, pvalue: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetValue(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskNamedValuePair {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskNamedValuePair_Vtbl { pub const fn new, Impl: ITaskNamedValuePair_Impl, const OFFSET: isize>() -> ITaskNamedValuePair_Vtbl { unsafe extern "system" fn Name, Impl: ITaskNamedValuePair_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3059,22 +3059,22 @@ impl ITaskScheduler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskService_Impl: Sized + super::Com::IDispatch_Impl { fn GetFolder(&self, path: &::windows_core::BSTR) -> ::windows_core::Result; fn GetRunningTasks(&self, flags: i32) -> ::windows_core::Result; fn NewTask(&self, flags: u32) -> ::windows_core::Result; - fn Connect(&self, servername: &super::Variant::VARIANT, user: &super::Variant::VARIANT, domain: &super::Variant::VARIANT, password: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Connect(&self, servername: &::windows_core::VARIANT, user: &::windows_core::VARIANT, domain: &::windows_core::VARIANT, password: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Connected(&self) -> ::windows_core::Result; fn TargetServer(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ConnectedUser(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn ConnectedDomain(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn HighestVersion(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskService_Vtbl { pub const fn new, Impl: ITaskService_Impl, const OFFSET: isize>() -> ITaskService_Vtbl { unsafe extern "system" fn GetFolder, Impl: ITaskService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3110,7 +3110,7 @@ impl ITaskService_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Connect, Impl: ITaskService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servername: super::Variant::VARIANT, user: super::Variant::VARIANT, domain: super::Variant::VARIANT, password: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Connect, Impl: ITaskService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servername: ::std::mem::MaybeUninit<::windows_core::VARIANT>, user: ::std::mem::MaybeUninit<::windows_core::VARIANT>, domain: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Connect(::core::mem::transmute(&servername), ::core::mem::transmute(&user), ::core::mem::transmute(&domain), ::core::mem::transmute(&password)).into() @@ -3187,8 +3187,8 @@ impl ITaskService_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskSettings_Impl: Sized + super::Com::IDispatch_Impl { fn AllowDemandStart(&self, pallowdemandstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetAllowDemandStart(&self, allowdemandstart: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -3231,9 +3231,9 @@ pub trait ITaskSettings_Impl: Sized + super::Com::IDispatch_Impl { fn NetworkSettings(&self) -> ::windows_core::Result; fn SetNetworkSettings(&self, pnetworksettings: ::core::option::Option<&INetworkSettings>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskSettings_Vtbl { pub const fn new, Impl: ITaskSettings_Impl, const OFFSET: isize>() -> ITaskSettings_Vtbl { unsafe extern "system" fn AllowDemandStart, Impl: ITaskSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pallowdemandstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3496,17 +3496,17 @@ impl ITaskSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskSettings2_Impl: Sized + super::Com::IDispatch_Impl { fn DisallowStartOnRemoteAppSession(&self, pdisallowstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetDisallowStartOnRemoteAppSession(&self, disallowstart: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn UseUnifiedSchedulingEngine(&self, puseunifiedengine: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetUseUnifiedSchedulingEngine(&self, useunifiedengine: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskSettings2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskSettings2_Vtbl { pub const fn new, Impl: ITaskSettings2_Impl, const OFFSET: isize>() -> ITaskSettings2_Vtbl { unsafe extern "system" fn DisallowStartOnRemoteAppSession, Impl: ITaskSettings2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdisallowstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3541,8 +3541,8 @@ impl ITaskSettings2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITaskSettings3_Impl: Sized + ITaskSettings_Impl { fn DisallowStartOnRemoteAppSession(&self, pdisallowstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetDisallowStartOnRemoteAppSession(&self, disallowstart: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -3554,9 +3554,9 @@ pub trait ITaskSettings3_Impl: Sized + ITaskSettings_Impl { fn Volatile(&self, pvolatile: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetVolatile(&self, volatile: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITaskSettings3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITaskSettings3_Vtbl { pub const fn new, Impl: ITaskSettings3_Impl, const OFFSET: isize>() -> ITaskSettings3_Vtbl { unsafe extern "system" fn DisallowStartOnRemoteAppSession, Impl: ITaskSettings3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdisallowstart: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3719,15 +3719,15 @@ impl ITaskVariables_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITimeTrigger_Impl: Sized + ITrigger_Impl { fn RandomDelay(&self, prandomdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetRandomDelay(&self, randomdelay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITimeTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITimeTrigger_Vtbl { pub const fn new, Impl: ITimeTrigger_Impl, const OFFSET: isize>() -> ITimeTrigger_Vtbl { unsafe extern "system" fn RandomDelay, Impl: ITimeTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, prandomdelay: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3750,8 +3750,8 @@ impl ITimeTrigger_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITrigger_Impl: Sized + super::Com::IDispatch_Impl { fn Type(&self, ptype: *mut TASK_TRIGGER_TYPE2) -> ::windows_core::Result<()>; fn Id(&self, pid: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3767,9 +3767,9 @@ pub trait ITrigger_Impl: Sized + super::Com::IDispatch_Impl { fn Enabled(&self, penabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetEnabled(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITrigger_Vtbl { pub const fn new, Impl: ITrigger_Impl, const OFFSET: isize>() -> ITrigger_Vtbl { unsafe extern "system" fn Type, Impl: ITrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptype: *mut TASK_TRIGGER_TYPE2) -> ::windows_core::HRESULT { @@ -3864,19 +3864,19 @@ impl ITrigger_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITriggerCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Count(&self, pcount: *mut i32) -> ::windows_core::Result<()>; fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Create(&self, r#type: TASK_TRIGGER_TYPE2) -> ::windows_core::Result; - fn Remove(&self, index: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITriggerCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITriggerCollection_Vtbl { pub const fn new, Impl: ITriggerCollection_Impl, const OFFSET: isize>() -> ITriggerCollection_Vtbl { unsafe extern "system" fn Count, Impl: ITriggerCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -3917,7 +3917,7 @@ impl ITriggerCollection_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: ITriggerCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: ITriggerCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&index)).into() @@ -3941,8 +3941,8 @@ impl ITriggerCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWeeklyTrigger_Impl: Sized + ITrigger_Impl { fn DaysOfWeek(&self, pdays: *mut i16) -> ::windows_core::Result<()>; fn SetDaysOfWeek(&self, days: i16) -> ::windows_core::Result<()>; @@ -3951,9 +3951,9 @@ pub trait IWeeklyTrigger_Impl: Sized + ITrigger_Impl { fn RandomDelay(&self, prandomdelay: *mut ::windows_core::BSTR) -> ::windows_core::Result<()>; fn SetRandomDelay(&self, randomdelay: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWeeklyTrigger {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWeeklyTrigger_Vtbl { pub const fn new, Impl: IWeeklyTrigger_Impl, const OFFSET: isize>() -> IWeeklyTrigger_Vtbl { unsafe extern "system" fn DaysOfWeek, Impl: IWeeklyTrigger_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdays: *mut i16) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/mod.rs b/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/mod.rs index 5dc4bd4a62..2c2da38a3a 100644 --- a/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/TaskScheduler/mod.rs @@ -70,10 +70,11 @@ impl IActionCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), r#type, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -105,10 +106,7 @@ pub struct IActionCollection_Vtbl { pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: TASK_ACTION_TYPE, ppaction: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Create: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Context: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcontext: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1547,20 +1545,24 @@ impl IRegisteredTask { { (::windows_core::Interface::vtable(self).SetEnabled)(::windows_core::Interface::as_raw(self), enabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Run(&self, params: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Run(&self, params: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Run)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(params), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Run)(::windows_core::Interface::as_raw(self), params.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RunEx(&self, params: super::Variant::VARIANT, flags: i32, sessionid: i32, user: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RunEx(&self, params: P0, flags: i32, sessionid: i32, user: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).RunEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(params), flags, sessionid, user.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).RunEx)(::windows_core::Interface::as_raw(self), params.into_param().abi(), flags, sessionid, user.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1621,13 +1623,13 @@ pub struct IRegisteredTask_Vtbl { pub State: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstate: *mut TASK_STATE) -> ::windows_core::HRESULT, pub Enabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Run: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, params: super::Variant::VARIANT, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Run: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, params: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Run: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RunEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, params: super::Variant::VARIANT, flags: i32, sessionid: i32, user: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RunEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, params: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: i32, sessionid: i32, user: ::std::mem::MaybeUninit<::windows_core::BSTR>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RunEx: usize, #[cfg(feature = "Win32_System_Com")] pub GetInstances: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: i32, pprunningtasks: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1662,11 +1664,14 @@ impl IRegisteredTaskCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -1679,9 +1684,9 @@ impl IRegisteredTaskCollection { pub struct IRegisteredTaskCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppregisteredtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppregisteredtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -1759,15 +1764,14 @@ impl IRegistrationInfo { { (::windows_core::Interface::vtable(self).SetURI)(::windows_core::Interface::as_raw(self), uri.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SecurityDescriptor(&self, psddl: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SecurityDescriptor)(::windows_core::Interface::as_raw(self), psddl).ok() + pub unsafe fn SecurityDescriptor(&self, psddl: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SecurityDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(psddl)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSecurityDescriptor(&self, sddl: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSecurityDescriptor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(sddl)).ok() + pub unsafe fn SetSecurityDescriptor(&self, sddl: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSecurityDescriptor)(::windows_core::Interface::as_raw(self), sddl.into_param().abi()).ok() } pub unsafe fn Source(&self, psource: *mut ::windows_core::BSTR) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Source)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(psource)).ok() @@ -1798,14 +1802,8 @@ pub struct IRegistrationInfo_Vtbl { pub SetXmlText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub URI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, puri: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetURI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uri: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psddl: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SecurityDescriptor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sddl: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSecurityDescriptor: usize, + pub SecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psddl: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Source: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psource: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSource: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, source: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -2022,11 +2020,14 @@ impl IRunningTaskCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -2039,9 +2040,9 @@ impl IRunningTaskCollection { pub struct IRunningTaskCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pprunningtask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -2725,14 +2726,15 @@ impl ITaskFolder { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFolders)(::windows_core::Interface::as_raw(self), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateFolder(&self, subfoldername: P0, sddl: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateFolder(&self, subfoldername: P0, sddl: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateFolder)(::windows_core::Interface::as_raw(self), subfoldername.into_param().abi(), ::core::mem::transmute(sddl), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateFolder)(::windows_core::Interface::as_raw(self), subfoldername.into_param().abi(), sddl.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn DeleteFolder(&self, subfoldername: P0, flags: i32) -> ::windows_core::Result<()> where @@ -2761,25 +2763,31 @@ impl ITaskFolder { { (::windows_core::Interface::vtable(self).DeleteTask)(::windows_core::Interface::as_raw(self), name.into_param().abi(), flags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterTask(&self, path: P0, xmltext: P1, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RegisterTask(&self, path: P0, xmltext: P1, flags: i32, userid: P2, password: P3, logontype: TASK_LOGON_TYPE, sddl: P4) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).RegisterTask)(::windows_core::Interface::as_raw(self), path.into_param().abi(), xmltext.into_param().abi(), flags, ::core::mem::transmute(userid), ::core::mem::transmute(password), logontype, ::core::mem::transmute(sddl), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).RegisterTask)(::windows_core::Interface::as_raw(self), path.into_param().abi(), xmltext.into_param().abi(), flags, userid.into_param().abi(), password.into_param().abi(), logontype, sddl.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterTaskDefinition(&self, path: P0, pdefinition: P1, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn RegisterTaskDefinition(&self, path: P0, pdefinition: P1, flags: i32, userid: P2, password: P3, logontype: TASK_LOGON_TYPE, sddl: P4) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).RegisterTaskDefinition)(::windows_core::Interface::as_raw(self), path.into_param().abi(), pdefinition.into_param().abi(), flags, ::core::mem::transmute(userid), ::core::mem::transmute(password), logontype, ::core::mem::transmute(sddl), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).RegisterTaskDefinition)(::windows_core::Interface::as_raw(self), path.into_param().abi(), pdefinition.into_param().abi(), flags, userid.into_param().abi(), password.into_param().abi(), logontype, sddl.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn GetSecurityDescriptor(&self, securityinformation: i32) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2807,9 +2815,9 @@ pub struct ITaskFolder_Vtbl { pub GetFolders: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: i32, ppfolders: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetFolders: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, subfoldername: ::std::mem::MaybeUninit<::windows_core::BSTR>, sddl: super::Variant::VARIANT, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, subfoldername: ::std::mem::MaybeUninit<::windows_core::BSTR>, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateFolder: usize, pub DeleteFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, subfoldername: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -2821,13 +2829,13 @@ pub struct ITaskFolder_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] GetTasks: usize, pub DeleteTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, xmltext: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RegisterTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, xmltext: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, userid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>, logontype: TASK_LOGON_TYPE, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RegisterTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterTaskDefinition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdefinition: *mut ::core::ffi::c_void, flags: i32, userid: super::Variant::VARIANT, password: super::Variant::VARIANT, logontype: TASK_LOGON_TYPE, sddl: super::Variant::VARIANT, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub RegisterTaskDefinition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, path: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdefinition: *mut ::core::ffi::c_void, flags: i32, userid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>, logontype: TASK_LOGON_TYPE, sddl: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pptask: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] RegisterTaskDefinition: usize, pub GetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, securityinformation: i32, psddl: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetSecurityDescriptor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sddl: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32) -> ::windows_core::HRESULT, @@ -2847,11 +2855,14 @@ impl ITaskFolderCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Item(&self, index: super::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -2864,9 +2875,9 @@ impl ITaskFolderCollection { pub struct ITaskFolderCollection_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppfolder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -3115,10 +3126,14 @@ impl ITaskService { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).NewTask)(::windows_core::Interface::as_raw(self), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Connect(&self, servername: super::Variant::VARIANT, user: super::Variant::VARIANT, domain: super::Variant::VARIANT, password: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Connect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(servername), ::core::mem::transmute(user), ::core::mem::transmute(domain), ::core::mem::transmute(password)).ok() + pub unsafe fn Connect(&self, servername: P0, user: P1, domain: P2, password: P3) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Connect)(::windows_core::Interface::as_raw(self), servername.into_param().abi(), user.into_param().abi(), domain.into_param().abi(), password.into_param().abi()).ok() } pub unsafe fn Connected(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3158,10 +3173,7 @@ pub struct ITaskService_Vtbl { pub NewTask: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: u32, ppdefinition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] NewTask: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Connect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servername: super::Variant::VARIANT, user: super::Variant::VARIANT, domain: super::Variant::VARIANT, password: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Connect: usize, + pub Connect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servername: ::std::mem::MaybeUninit<::windows_core::VARIANT>, user: ::std::mem::MaybeUninit<::windows_core::VARIANT>, domain: ::std::mem::MaybeUninit<::windows_core::VARIANT>, password: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Connected: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pconnected: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub TargetServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pserver: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub ConnectedUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, puser: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -3985,10 +3997,11 @@ impl ITriggerCollection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Create)(::windows_core::Interface::as_raw(self), r#type, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, index: super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index)).ok() + pub unsafe fn Remove(&self, index: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), index.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -4009,10 +4022,7 @@ pub struct ITriggerCollection_Vtbl { pub Create: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: TASK_TRIGGER_TYPE2, pptrigger: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Create: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] diff --git a/crates/libs/windows/src/Windows/Win32/System/TransactionServer/impl.rs b/crates/libs/windows/src/Windows/Win32/System/TransactionServer/impl.rs index 333f2b9010..c0c4a48b1f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/TransactionServer/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/TransactionServer/impl.rs @@ -1,14 +1,14 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICatalog_Impl: Sized + super::Com::IDispatch_Impl { fn GetCollection(&self, bstrcollname: &::windows_core::BSTR) -> ::windows_core::Result; fn Connect(&self, bstrconnectstring: &::windows_core::BSTR) -> ::windows_core::Result; fn MajorVersion(&self, retval: *mut i32) -> ::windows_core::Result<()>; fn MinorVersion(&self, retval: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICatalog {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICatalog_Vtbl { pub const fn new, Impl: ICatalog_Impl, const OFFSET: isize>() -> ICatalog_Vtbl { unsafe extern "system" fn GetCollection, Impl: ICatalog_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrcollname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppcatalogcollection: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -55,17 +55,17 @@ impl ICatalog_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IComponentUtil_Impl: Sized + super::Com::IDispatch_Impl { fn InstallComponent(&self, bstrdllfile: &::windows_core::BSTR, bstrtypelibfile: &::windows_core::BSTR, bstrproxystubdllfile: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ImportComponent(&self, bstrclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn ImportComponentByName(&self, bstrprogid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetCLSIDs(&self, bstrdllfile: &::windows_core::BSTR, bstrtypelibfile: &::windows_core::BSTR, aclsids: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IComponentUtil {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IComponentUtil_Vtbl { pub const fn new, Impl: IComponentUtil_Impl, const OFFSET: isize>() -> IComponentUtil_Vtbl { unsafe extern "system" fn InstallComponent, Impl: IComponentUtil_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrdllfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtypelibfile: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrproxystubdllfile: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -100,16 +100,16 @@ impl IComponentUtil_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPackageUtil_Impl: Sized + super::Com::IDispatch_Impl { fn InstallPackage(&self, bstrpackagefile: &::windows_core::BSTR, bstrinstallpath: &::windows_core::BSTR, loptions: i32) -> ::windows_core::Result<()>; fn ExportPackage(&self, bstrpackageid: &::windows_core::BSTR, bstrpackagefile: &::windows_core::BSTR, loptions: i32) -> ::windows_core::Result<()>; fn ShutdownPackage(&self, bstrpackageid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPackageUtil {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPackageUtil_Vtbl { pub const fn new, Impl: IPackageUtil_Impl, const OFFSET: isize>() -> IPackageUtil_Vtbl { unsafe extern "system" fn InstallPackage, Impl: IPackageUtil_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpackagefile: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrinstallpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, loptions: i32) -> ::windows_core::HRESULT { @@ -138,15 +138,15 @@ impl IPackageUtil_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRemoteComponentUtil_Impl: Sized + super::Com::IDispatch_Impl { fn InstallRemoteComponent(&self, bstrserver: &::windows_core::BSTR, bstrpackageid: &::windows_core::BSTR, bstrclsid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn InstallRemoteComponentByName(&self, bstrserver: &::windows_core::BSTR, bstrpackagename: &::windows_core::BSTR, bstrprogid: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRemoteComponentUtil {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRemoteComponentUtil_Vtbl { pub const fn new, Impl: IRemoteComponentUtil_Impl, const OFFSET: isize>() -> IRemoteComponentUtil_Vtbl { unsafe extern "system" fn InstallRemoteComponent, Impl: IRemoteComponentUtil_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrserver: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrpackageid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -169,15 +169,15 @@ impl IRemoteComponentUtil_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IRoleAssociationUtil_Impl: Sized + super::Com::IDispatch_Impl { fn AssociateRole(&self, bstrroleid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AssociateRoleByName(&self, bstrrolename: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IRoleAssociationUtil {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IRoleAssociationUtil_Vtbl { pub const fn new, Impl: IRoleAssociationUtil_Impl, const OFFSET: isize>() -> IRoleAssociationUtil_Vtbl { unsafe extern "system" fn AssociateRole, Impl: IRoleAssociationUtil_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrroleid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/impl.rs b/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/impl.rs index 83c35e357c..9d0752c8a9 100644 --- a/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/impl.rs @@ -1,5 +1,5 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdates_Impl: Sized + super::Com::IDispatch_Impl { fn DetectNow(&self) -> ::windows_core::Result<()>; fn Pause(&self) -> ::windows_core::Result<()>; @@ -9,9 +9,9 @@ pub trait IAutomaticUpdates_Impl: Sized + super::Com::IDispatch_Impl { fn ServiceEnabled(&self) -> ::windows_core::Result; fn EnableService(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdates {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdates_Vtbl { pub const fn new, Impl: IAutomaticUpdates_Impl, const OFFSET: isize>() -> IAutomaticUpdates_Vtbl { unsafe extern "system" fn DetectNow, Impl: IAutomaticUpdates_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -76,14 +76,14 @@ impl IAutomaticUpdates_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdates2_Impl: Sized + IAutomaticUpdates_Impl { fn Results(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdates2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdates2_Vtbl { pub const fn new, Impl: IAutomaticUpdates2_Impl, const OFFSET: isize>() -> IAutomaticUpdates2_Vtbl { unsafe extern "system" fn Results, Impl: IAutomaticUpdates2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -103,18 +103,18 @@ impl IAutomaticUpdates2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdatesResults_Impl: Sized + super::Com::IDispatch_Impl { - fn LastSearchSuccessDate(&self) -> ::windows_core::Result; - fn LastInstallationSuccessDate(&self) -> ::windows_core::Result; + fn LastSearchSuccessDate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn LastInstallationSuccessDate(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdatesResults {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdatesResults_Vtbl { pub const fn new, Impl: IAutomaticUpdatesResults_Impl, const OFFSET: isize>() -> IAutomaticUpdatesResults_Vtbl { - unsafe extern "system" fn LastSearchSuccessDate, Impl: IAutomaticUpdatesResults_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastSearchSuccessDate, Impl: IAutomaticUpdatesResults_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastSearchSuccessDate() { @@ -125,7 +125,7 @@ impl IAutomaticUpdatesResults_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn LastInstallationSuccessDate, Impl: IAutomaticUpdatesResults_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LastInstallationSuccessDate, Impl: IAutomaticUpdatesResults_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.LastInstallationSuccessDate() { @@ -146,8 +146,8 @@ impl IAutomaticUpdatesResults_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdatesSettings_Impl: Sized + super::Com::IDispatch_Impl { fn NotificationLevel(&self) -> ::windows_core::Result; fn SetNotificationLevel(&self, value: AutomaticUpdatesNotificationLevel) -> ::windows_core::Result<()>; @@ -160,9 +160,9 @@ pub trait IAutomaticUpdatesSettings_Impl: Sized + super::Com::IDispatch_Impl { fn Refresh(&self) -> ::windows_core::Result<()>; fn Save(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdatesSettings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdatesSettings_Vtbl { pub const fn new, Impl: IAutomaticUpdatesSettings_Impl, const OFFSET: isize>() -> IAutomaticUpdatesSettings_Vtbl { unsafe extern "system" fn NotificationLevel, Impl: IAutomaticUpdatesSettings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut AutomaticUpdatesNotificationLevel) -> ::windows_core::HRESULT { @@ -263,16 +263,16 @@ impl IAutomaticUpdatesSettings_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdatesSettings2_Impl: Sized + IAutomaticUpdatesSettings_Impl { fn IncludeRecommendedUpdates(&self) -> ::windows_core::Result; fn SetIncludeRecommendedUpdates(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn CheckPermission(&self, usertype: AutomaticUpdatesUserType, permissiontype: AutomaticUpdatesPermissionType) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdatesSettings2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdatesSettings2_Vtbl { pub const fn new, Impl: IAutomaticUpdatesSettings2_Impl, const OFFSET: isize>() -> IAutomaticUpdatesSettings2_Vtbl { unsafe extern "system" fn IncludeRecommendedUpdates, Impl: IAutomaticUpdatesSettings2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -313,17 +313,17 @@ impl IAutomaticUpdatesSettings2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAutomaticUpdatesSettings3_Impl: Sized + IAutomaticUpdatesSettings2_Impl { fn NonAdministratorsElevated(&self) -> ::windows_core::Result; fn SetNonAdministratorsElevated(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn FeaturedUpdatesEnabled(&self) -> ::windows_core::Result; fn SetFeaturedUpdatesEnabled(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAutomaticUpdatesSettings3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdatesSettings3_Vtbl { pub const fn new, Impl: IAutomaticUpdatesSettings3_Impl, const OFFSET: isize>() -> IAutomaticUpdatesSettings3_Vtbl { unsafe extern "system" fn NonAdministratorsElevated, Impl: IAutomaticUpdatesSettings3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -370,8 +370,8 @@ impl IAutomaticUpdatesSettings3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICategory_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CategoryID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -383,9 +383,9 @@ pub trait ICategory_Impl: Sized + super::Com::IDispatch_Impl { fn Type(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Updates(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICategory {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICategory_Vtbl { pub const fn new, Impl: ICategory_Impl, const OFFSET: isize>() -> ICategory_Vtbl { unsafe extern "system" fn Name, Impl: ICategory_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -504,16 +504,16 @@ impl ICategory_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ICategoryCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ICategoryCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ICategoryCollection_Vtbl { pub const fn new, Impl: ICategoryCollection_Impl, const OFFSET: isize>() -> ICategoryCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: ICategoryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -581,12 +581,12 @@ impl IDownloadCompletedCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadCompletedCallbackArgs_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadCompletedCallbackArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadCompletedCallbackArgs_Vtbl { pub const fn new, Impl: IDownloadCompletedCallbackArgs_Impl, const OFFSET: isize>() -> IDownloadCompletedCallbackArgs_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -595,22 +595,22 @@ impl IDownloadCompletedCallbackArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadJob_Impl: Sized + super::Com::IDispatch_Impl { - fn AsyncState(&self) -> ::windows_core::Result; + fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsCompleted(&self) -> ::windows_core::Result; fn Updates(&self) -> ::windows_core::Result; fn CleanUp(&self) -> ::windows_core::Result<()>; fn GetProgress(&self) -> ::windows_core::Result; fn RequestAbort(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadJob_Vtbl { pub const fn new, Impl: IDownloadJob_Impl, const OFFSET: isize>() -> IDownloadJob_Vtbl { - unsafe extern "system" fn AsyncState, Impl: IDownloadJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AsyncState, Impl: IDownloadJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AsyncState() { @@ -678,8 +678,8 @@ impl IDownloadJob_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadProgress_Impl: Sized + super::Com::IDispatch_Impl { fn CurrentUpdateBytesDownloaded(&self) -> ::windows_core::Result; fn CurrentUpdateBytesToDownload(&self) -> ::windows_core::Result; @@ -691,9 +691,9 @@ pub trait IDownloadProgress_Impl: Sized + super::Com::IDispatch_Impl { fn CurrentUpdateDownloadPhase(&self) -> ::windows_core::Result; fn CurrentUpdatePercentComplete(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadProgress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadProgress_Vtbl { pub const fn new, Impl: IDownloadProgress_Impl, const OFFSET: isize>() -> IDownloadProgress_Vtbl { unsafe extern "system" fn CurrentUpdateBytesDownloaded, Impl: IDownloadProgress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::DECIMAL) -> ::windows_core::HRESULT { @@ -833,14 +833,14 @@ impl IDownloadProgressChangedCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadProgressChangedCallbackArgs_Impl: Sized + super::Com::IDispatch_Impl { fn Progress(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadProgressChangedCallbackArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadProgressChangedCallbackArgs_Vtbl { pub const fn new, Impl: IDownloadProgressChangedCallbackArgs_Impl, const OFFSET: isize>() -> IDownloadProgressChangedCallbackArgs_Vtbl { unsafe extern "system" fn Progress, Impl: IDownloadProgressChangedCallbackArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -860,16 +860,16 @@ impl IDownloadProgressChangedCallbackArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadResult_Impl: Sized + super::Com::IDispatch_Impl { fn HResult(&self) -> ::windows_core::Result; fn ResultCode(&self) -> ::windows_core::Result; fn GetUpdateResult(&self, updateindex: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadResult_Vtbl { pub const fn new, Impl: IDownloadResult_Impl, const OFFSET: isize>() -> IDownloadResult_Vtbl { unsafe extern "system" fn HResult, Impl: IDownloadResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -916,17 +916,17 @@ impl IDownloadResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IImageInformation_Impl: Sized + super::Com::IDispatch_Impl { fn AltText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Height(&self) -> ::windows_core::Result; fn Source(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Width(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IImageInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IImageInformation_Vtbl { pub const fn new, Impl: IImageInformation_Impl, const OFFSET: isize>() -> IImageInformation_Vtbl { unsafe extern "system" fn AltText, Impl: IImageInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -985,14 +985,14 @@ impl IImageInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationAgent_Impl: Sized + super::Com::IDispatch_Impl { fn RecordInstallationResult(&self, installationresultcookie: &::windows_core::BSTR, hresult: i32, extendedreportingdata: ::core::option::Option<&IStringCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationAgent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationAgent_Vtbl { pub const fn new, Impl: IInstallationAgent_Impl, const OFFSET: isize>() -> IInstallationAgent_Vtbl { unsafe extern "system" fn RecordInstallationResult, Impl: IInstallationAgent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, installationresultcookie: ::std::mem::MaybeUninit<::windows_core::BSTR>, hresult: i32, extendedreportingdata: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1009,17 +1009,17 @@ impl IInstallationAgent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationBehavior_Impl: Sized + super::Com::IDispatch_Impl { fn CanRequestUserInput(&self) -> ::windows_core::Result; fn Impact(&self) -> ::windows_core::Result; fn RebootBehavior(&self) -> ::windows_core::Result; fn RequiresNetworkConnectivity(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationBehavior {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationBehavior_Vtbl { pub const fn new, Impl: IInstallationBehavior_Impl, const OFFSET: isize>() -> IInstallationBehavior_Vtbl { unsafe extern "system" fn CanRequestUserInput, Impl: IInstallationBehavior_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1099,12 +1099,12 @@ impl IInstallationCompletedCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationCompletedCallbackArgs_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationCompletedCallbackArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationCompletedCallbackArgs_Vtbl { pub const fn new, Impl: IInstallationCompletedCallbackArgs_Impl, const OFFSET: isize>() -> IInstallationCompletedCallbackArgs_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -1113,22 +1113,22 @@ impl IInstallationCompletedCallbackArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationJob_Impl: Sized + super::Com::IDispatch_Impl { - fn AsyncState(&self) -> ::windows_core::Result; + fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsCompleted(&self) -> ::windows_core::Result; fn Updates(&self) -> ::windows_core::Result; fn CleanUp(&self) -> ::windows_core::Result<()>; fn GetProgress(&self) -> ::windows_core::Result; fn RequestAbort(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationJob_Vtbl { pub const fn new, Impl: IInstallationJob_Impl, const OFFSET: isize>() -> IInstallationJob_Vtbl { - unsafe extern "system" fn AsyncState, Impl: IInstallationJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AsyncState, Impl: IInstallationJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AsyncState() { @@ -1196,17 +1196,17 @@ impl IInstallationJob_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationProgress_Impl: Sized + super::Com::IDispatch_Impl { fn CurrentUpdateIndex(&self) -> ::windows_core::Result; fn CurrentUpdatePercentComplete(&self) -> ::windows_core::Result; fn PercentComplete(&self) -> ::windows_core::Result; fn GetUpdateResult(&self, updateindex: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationProgress {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationProgress_Vtbl { pub const fn new, Impl: IInstallationProgress_Impl, const OFFSET: isize>() -> IInstallationProgress_Vtbl { unsafe extern "system" fn CurrentUpdateIndex, Impl: IInstallationProgress_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -1286,14 +1286,14 @@ impl IInstallationProgressChangedCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationProgressChangedCallbackArgs_Impl: Sized + super::Com::IDispatch_Impl { fn Progress(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationProgressChangedCallbackArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationProgressChangedCallbackArgs_Vtbl { pub const fn new, Impl: IInstallationProgressChangedCallbackArgs_Impl, const OFFSET: isize>() -> IInstallationProgressChangedCallbackArgs_Vtbl { unsafe extern "system" fn Progress, Impl: IInstallationProgressChangedCallbackArgs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1313,17 +1313,17 @@ impl IInstallationProgressChangedCallbackArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInstallationResult_Impl: Sized + super::Com::IDispatch_Impl { fn HResult(&self) -> ::windows_core::Result; fn RebootRequired(&self) -> ::windows_core::Result; fn ResultCode(&self) -> ::windows_core::Result; fn GetUpdateResult(&self, updateindex: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInstallationResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInstallationResult_Vtbl { pub const fn new, Impl: IInstallationResult_Impl, const OFFSET: isize>() -> IInstallationResult_Vtbl { unsafe extern "system" fn HResult, Impl: IInstallationResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -1382,14 +1382,14 @@ impl IInstallationResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInvalidProductLicenseException_Impl: Sized + IUpdateException_Impl { fn Product(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInvalidProductLicenseException {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInvalidProductLicenseException_Vtbl { pub const fn new, Impl: IInvalidProductLicenseException_Impl, const OFFSET: isize>() -> IInvalidProductLicenseException_Vtbl { unsafe extern "system" fn Product, Impl: IInvalidProductLicenseException_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1430,12 +1430,12 @@ impl ISearchCompletedCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISearchCompletedCallbackArgs_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISearchCompletedCallbackArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISearchCompletedCallbackArgs_Vtbl { pub const fn new, Impl: ISearchCompletedCallbackArgs_Impl, const OFFSET: isize>() -> ISearchCompletedCallbackArgs_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -1444,20 +1444,20 @@ impl ISearchCompletedCallbackArgs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISearchJob_Impl: Sized + super::Com::IDispatch_Impl { - fn AsyncState(&self) -> ::windows_core::Result; + fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn IsCompleted(&self) -> ::windows_core::Result; fn CleanUp(&self) -> ::windows_core::Result<()>; fn RequestAbort(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISearchJob {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISearchJob_Vtbl { pub const fn new, Impl: ISearchJob_Impl, const OFFSET: isize>() -> ISearchJob_Vtbl { - unsafe extern "system" fn AsyncState, Impl: ISearchJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AsyncState, Impl: ISearchJob_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.AsyncState() { @@ -1501,17 +1501,17 @@ impl ISearchJob_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISearchResult_Impl: Sized + super::Com::IDispatch_Impl { fn ResultCode(&self) -> ::windows_core::Result; fn RootCategories(&self) -> ::windows_core::Result; fn Updates(&self) -> ::windows_core::Result; fn Warnings(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISearchResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISearchResult_Vtbl { pub const fn new, Impl: ISearchResult_Impl, const OFFSET: isize>() -> ISearchResult_Vtbl { unsafe extern "system" fn ResultCode, Impl: ISearchResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut OperationResultCode) -> ::windows_core::HRESULT { @@ -1570,8 +1570,8 @@ impl ISearchResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IStringCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result<::windows_core::BSTR>; fn put_Item(&self, index: i32, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1584,9 +1584,9 @@ pub trait IStringCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Insert(&self, index: i32, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RemoveAt(&self, index: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IStringCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IStringCollection_Vtbl { pub const fn new, Impl: IStringCollection_Impl, const OFFSET: isize>() -> IStringCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IStringCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1693,15 +1693,15 @@ impl IStringCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISystemInformation_Impl: Sized + super::Com::IDispatch_Impl { fn OemHardwareSupportLink(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RebootRequired(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISystemInformation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISystemInformation_Vtbl { pub const fn new, Impl: ISystemInformation_Impl, const OFFSET: isize>() -> ISystemInformation_Vtbl { unsafe extern "system" fn OemHardwareSupportLink, Impl: ISystemInformation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1736,15 +1736,15 @@ impl ISystemInformation_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdate_Impl: Sized + super::Com::IDispatch_Impl { fn Title(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn AutoSelectOnWebSites(&self) -> ::windows_core::Result; fn BundledUpdates(&self) -> ::windows_core::Result; fn CanRequireSource(&self) -> ::windows_core::Result; fn Categories(&self) -> ::windows_core::Result; - fn Deadline(&self) -> ::windows_core::Result; + fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DeltaCompressedContentAvailable(&self) -> ::windows_core::Result; fn DeltaCompressedContentPreferred(&self) -> ::windows_core::Result; fn Description(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1785,9 +1785,9 @@ pub trait IUpdate_Impl: Sized + super::Com::IDispatch_Impl { fn DownloadPriority(&self) -> ::windows_core::Result; fn DownloadContents(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdate_Vtbl { pub const fn new, Impl: IUpdate_Impl, const OFFSET: isize>() -> IUpdate_Vtbl { unsafe extern "system" fn Title, Impl: IUpdate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1845,7 +1845,7 @@ impl IUpdate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Deadline, Impl: IUpdate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Deadline, Impl: IUpdate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Deadline() { @@ -2320,17 +2320,17 @@ impl IUpdate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdate2_Impl: Sized + IUpdate_Impl { fn RebootRequired(&self) -> ::windows_core::Result; fn IsPresent(&self) -> ::windows_core::Result; fn CveIDs(&self) -> ::windows_core::Result; fn CopyToCache(&self, pfiles: ::core::option::Option<&IStringCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdate2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdate2_Vtbl { pub const fn new, Impl: IUpdate2_Impl, const OFFSET: isize>() -> IUpdate2_Vtbl { unsafe extern "system" fn RebootRequired, Impl: IUpdate2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2383,14 +2383,14 @@ impl IUpdate2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdate3_Impl: Sized + IUpdate2_Impl { fn BrowseOnly(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdate3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdate3_Vtbl { pub const fn new, Impl: IUpdate3_Impl, const OFFSET: isize>() -> IUpdate3_Vtbl { unsafe extern "system" fn BrowseOnly, Impl: IUpdate3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2410,14 +2410,14 @@ impl IUpdate3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdate4_Impl: Sized + IUpdate3_Impl { fn PerUser(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdate4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdate4_Vtbl { pub const fn new, Impl: IUpdate4_Impl, const OFFSET: isize>() -> IUpdate4_Vtbl { unsafe extern "system" fn PerUser, Impl: IUpdate4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2437,15 +2437,15 @@ impl IUpdate4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdate5_Impl: Sized + IUpdate4_Impl { fn AutoSelection(&self) -> ::windows_core::Result; fn AutoDownload(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdate5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdate5_Vtbl { pub const fn new, Impl: IUpdate5_Impl, const OFFSET: isize>() -> IUpdate5_Vtbl { unsafe extern "system" fn AutoSelection, Impl: IUpdate5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut AutoSelectionMode) -> ::windows_core::HRESULT { @@ -2480,8 +2480,8 @@ impl IUpdate5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn put_Item(&self, index: i32, value: ::core::option::Option<&IUpdate>) -> ::windows_core::Result<()>; @@ -2494,9 +2494,9 @@ pub trait IUpdateCollection_Impl: Sized + super::Com::IDispatch_Impl { fn Insert(&self, index: i32, value: ::core::option::Option<&IUpdate>) -> ::windows_core::Result<()>; fn RemoveAt(&self, index: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateCollection_Vtbl { pub const fn new, Impl: IUpdateCollection_Impl, const OFFSET: isize>() -> IUpdateCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IUpdateCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2603,14 +2603,14 @@ impl IUpdateCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateDownloadContent_Impl: Sized + super::Com::IDispatch_Impl { fn DownloadUrl(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateDownloadContent {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateDownloadContent_Vtbl { pub const fn new, Impl: IUpdateDownloadContent_Impl, const OFFSET: isize>() -> IUpdateDownloadContent_Vtbl { unsafe extern "system" fn DownloadUrl, Impl: IUpdateDownloadContent_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2630,14 +2630,14 @@ impl IUpdateDownloadContent_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateDownloadContent2_Impl: Sized + IUpdateDownloadContent_Impl { fn IsDeltaCompressedContent(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateDownloadContent2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateDownloadContent2_Vtbl { pub const fn new, Impl: IUpdateDownloadContent2_Impl, const OFFSET: isize>() -> IUpdateDownloadContent2_Vtbl { unsafe extern "system" fn IsDeltaCompressedContent, Impl: IUpdateDownloadContent2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -2660,16 +2660,16 @@ impl IUpdateDownloadContent2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateDownloadContentCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateDownloadContentCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateDownloadContentCollection_Vtbl { pub const fn new, Impl: IUpdateDownloadContentCollection_Impl, const OFFSET: isize>() -> IUpdateDownloadContentCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IUpdateDownloadContentCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2716,15 +2716,15 @@ impl IUpdateDownloadContentCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateDownloadResult_Impl: Sized + super::Com::IDispatch_Impl { fn HResult(&self) -> ::windows_core::Result; fn ResultCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateDownloadResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateDownloadResult_Vtbl { pub const fn new, Impl: IUpdateDownloadResult_Impl, const OFFSET: isize>() -> IUpdateDownloadResult_Vtbl { unsafe extern "system" fn HResult, Impl: IUpdateDownloadResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -2759,8 +2759,8 @@ impl IUpdateDownloadResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateDownloader_Impl: Sized + super::Com::IDispatch_Impl { fn ClientApplicationID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetClientApplicationID(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -2770,13 +2770,13 @@ pub trait IUpdateDownloader_Impl: Sized + super::Com::IDispatch_Impl { fn SetPriority(&self, value: DownloadPriority) -> ::windows_core::Result<()>; fn Updates(&self) -> ::windows_core::Result; fn SetUpdates(&self, value: ::core::option::Option<&IUpdateCollection>) -> ::windows_core::Result<()>; - fn BeginDownload(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &super::Variant::VARIANT) -> ::windows_core::Result; + fn BeginDownload(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &::windows_core::VARIANT) -> ::windows_core::Result; fn Download(&self) -> ::windows_core::Result; fn EndDownload(&self, value: ::core::option::Option<&IDownloadJob>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateDownloader {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateDownloader_Vtbl { pub const fn new, Impl: IUpdateDownloader_Impl, const OFFSET: isize>() -> IUpdateDownloader_Vtbl { unsafe extern "system" fn ClientApplicationID, Impl: IUpdateDownloader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2843,7 +2843,7 @@ impl IUpdateDownloader_Vtbl { let this = (*this).get_impl(); this.SetUpdates(::windows_core::from_raw_borrowed(&value)).into() } - unsafe extern "system" fn BeginDownload, Impl: IUpdateDownloader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginDownload, Impl: IUpdateDownloader_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BeginDownload(::windows_core::from_raw_borrowed(&onprogresschanged), ::windows_core::from_raw_borrowed(&oncompleted), ::core::mem::transmute(&state)) { @@ -2895,16 +2895,16 @@ impl IUpdateDownloader_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateException_Impl: Sized + super::Com::IDispatch_Impl { fn Message(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn HResult(&self) -> ::windows_core::Result; fn Context(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateException {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateException_Vtbl { pub const fn new, Impl: IUpdateException_Impl, const OFFSET: isize>() -> IUpdateException_Vtbl { unsafe extern "system" fn Message, Impl: IUpdateException_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2951,16 +2951,16 @@ impl IUpdateException_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateExceptionCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateExceptionCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateExceptionCollection_Vtbl { pub const fn new, Impl: IUpdateExceptionCollection_Impl, const OFFSET: isize>() -> IUpdateExceptionCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IUpdateExceptionCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3007,8 +3007,8 @@ impl IUpdateExceptionCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateHistoryEntry_Impl: Sized + super::Com::IDispatch_Impl { fn Operation(&self) -> ::windows_core::Result; fn ResultCode(&self) -> ::windows_core::Result; @@ -3025,9 +3025,9 @@ pub trait IUpdateHistoryEntry_Impl: Sized + super::Com::IDispatch_Impl { fn UninstallationNotes(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SupportUrl(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateHistoryEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateHistoryEntry_Vtbl { pub const fn new, Impl: IUpdateHistoryEntry_Impl, const OFFSET: isize>() -> IUpdateHistoryEntry_Vtbl { unsafe extern "system" fn Operation, Impl: IUpdateHistoryEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut UpdateOperation) -> ::windows_core::HRESULT { @@ -3206,14 +3206,14 @@ impl IUpdateHistoryEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateHistoryEntry2_Impl: Sized + IUpdateHistoryEntry_Impl { fn Categories(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateHistoryEntry2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateHistoryEntry2_Vtbl { pub const fn new, Impl: IUpdateHistoryEntry2_Impl, const OFFSET: isize>() -> IUpdateHistoryEntry2_Vtbl { unsafe extern "system" fn Categories, Impl: IUpdateHistoryEntry2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3233,16 +3233,16 @@ impl IUpdateHistoryEntry2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateHistoryEntryCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateHistoryEntryCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateHistoryEntryCollection_Vtbl { pub const fn new, Impl: IUpdateHistoryEntryCollection_Impl, const OFFSET: isize>() -> IUpdateHistoryEntryCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IUpdateHistoryEntryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3289,15 +3289,15 @@ impl IUpdateHistoryEntryCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateIdentity_Impl: Sized + super::Com::IDispatch_Impl { fn RevisionNumber(&self) -> ::windows_core::Result; fn UpdateID(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateIdentity {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateIdentity_Vtbl { pub const fn new, Impl: IUpdateIdentity_Impl, const OFFSET: isize>() -> IUpdateIdentity_Vtbl { unsafe extern "system" fn RevisionNumber, Impl: IUpdateIdentity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -3332,16 +3332,16 @@ impl IUpdateIdentity_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateInstallationResult_Impl: Sized + super::Com::IDispatch_Impl { fn HResult(&self) -> ::windows_core::Result; fn RebootRequired(&self) -> ::windows_core::Result; fn ResultCode(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateInstallationResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateInstallationResult_Vtbl { pub const fn new, Impl: IUpdateInstallationResult_Impl, const OFFSET: isize>() -> IUpdateInstallationResult_Vtbl { unsafe extern "system" fn HResult, Impl: IUpdateInstallationResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -3388,8 +3388,8 @@ impl IUpdateInstallationResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateInstaller_Impl: Sized + super::Com::IDispatch_Impl { fn ClientApplicationID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetClientApplicationID(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3401,8 +3401,8 @@ pub trait IUpdateInstaller_Impl: Sized + super::Com::IDispatch_Impl { fn ParentWindow(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Updates(&self) -> ::windows_core::Result; fn SetUpdates(&self, value: ::core::option::Option<&IUpdateCollection>) -> ::windows_core::Result<()>; - fn BeginInstall(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &super::Variant::VARIANT) -> ::windows_core::Result; - fn BeginUninstall(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &super::Variant::VARIANT) -> ::windows_core::Result; + fn BeginInstall(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &::windows_core::VARIANT) -> ::windows_core::Result; + fn BeginUninstall(&self, onprogresschanged: ::core::option::Option<&::windows_core::IUnknown>, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &::windows_core::VARIANT) -> ::windows_core::Result; fn EndInstall(&self, value: ::core::option::Option<&IInstallationJob>) -> ::windows_core::Result; fn EndUninstall(&self, value: ::core::option::Option<&IInstallationJob>) -> ::windows_core::Result; fn Install(&self) -> ::windows_core::Result; @@ -3413,9 +3413,9 @@ pub trait IUpdateInstaller_Impl: Sized + super::Com::IDispatch_Impl { fn SetAllowSourcePrompts(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn RebootRequiredBeforeInstallation(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateInstaller {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateInstaller_Vtbl { pub const fn new, Impl: IUpdateInstaller_Impl, const OFFSET: isize>() -> IUpdateInstaller_Vtbl { unsafe extern "system" fn ClientApplicationID, Impl: IUpdateInstaller_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3498,7 +3498,7 @@ impl IUpdateInstaller_Vtbl { let this = (*this).get_impl(); this.SetUpdates(::windows_core::from_raw_borrowed(&value)).into() } - unsafe extern "system" fn BeginInstall, Impl: IUpdateInstaller_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginInstall, Impl: IUpdateInstaller_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BeginInstall(::windows_core::from_raw_borrowed(&onprogresschanged), ::windows_core::from_raw_borrowed(&oncompleted), ::core::mem::transmute(&state)) { @@ -3509,7 +3509,7 @@ impl IUpdateInstaller_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BeginUninstall, Impl: IUpdateInstaller_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginUninstall, Impl: IUpdateInstaller_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BeginUninstall(::windows_core::from_raw_borrowed(&onprogresschanged), ::windows_core::from_raw_borrowed(&oncompleted), ::core::mem::transmute(&state)) { @@ -3642,15 +3642,15 @@ impl IUpdateInstaller_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateInstaller2_Impl: Sized + IUpdateInstaller_Impl { fn ForceQuiet(&self) -> ::windows_core::Result; fn SetForceQuiet(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateInstaller2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateInstaller2_Vtbl { pub const fn new, Impl: IUpdateInstaller2_Impl, const OFFSET: isize>() -> IUpdateInstaller2_Vtbl { unsafe extern "system" fn ForceQuiet, Impl: IUpdateInstaller2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3679,15 +3679,15 @@ impl IUpdateInstaller2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateInstaller3_Impl: Sized + IUpdateInstaller2_Impl { fn AttemptCloseAppsIfNecessary(&self) -> ::windows_core::Result; fn SetAttemptCloseAppsIfNecessary(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateInstaller3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateInstaller3_Vtbl { pub const fn new, Impl: IUpdateInstaller3_Impl, const OFFSET: isize>() -> IUpdateInstaller3_Vtbl { unsafe extern "system" fn AttemptCloseAppsIfNecessary, Impl: IUpdateInstaller3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3716,14 +3716,14 @@ impl IUpdateInstaller3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateInstaller4_Impl: Sized + IUpdateInstaller3_Impl { fn Commit(&self, dwflags: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateInstaller4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateInstaller4_Vtbl { pub const fn new, Impl: IUpdateInstaller4_Impl, const OFFSET: isize>() -> IUpdateInstaller4_Vtbl { unsafe extern "system" fn Commit, Impl: IUpdateInstaller4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwflags: u32) -> ::windows_core::HRESULT { @@ -3754,8 +3754,8 @@ impl IUpdateLockdown_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSearcher_Impl: Sized + super::Com::IDispatch_Impl { fn CanAutomaticallyUpgradeService(&self) -> ::windows_core::Result; fn SetCanAutomaticallyUpgradeService(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -3765,7 +3765,7 @@ pub trait IUpdateSearcher_Impl: Sized + super::Com::IDispatch_Impl { fn SetIncludePotentiallySupersededUpdates(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ServerSelection(&self) -> ::windows_core::Result; fn SetServerSelection(&self, value: ServerSelection) -> ::windows_core::Result<()>; - fn BeginSearch(&self, criteria: &::windows_core::BSTR, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &super::Variant::VARIANT) -> ::windows_core::Result; + fn BeginSearch(&self, criteria: &::windows_core::BSTR, oncompleted: ::core::option::Option<&::windows_core::IUnknown>, state: &::windows_core::VARIANT) -> ::windows_core::Result; fn EndSearch(&self, searchjob: ::core::option::Option<&ISearchJob>) -> ::windows_core::Result; fn EscapeString(&self, unescaped: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn QueryHistory(&self, startindex: i32, count: i32) -> ::windows_core::Result; @@ -3776,9 +3776,9 @@ pub trait IUpdateSearcher_Impl: Sized + super::Com::IDispatch_Impl { fn ServiceID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetServiceID(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSearcher {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSearcher_Vtbl { pub const fn new, Impl: IUpdateSearcher_Impl, const OFFSET: isize>() -> IUpdateSearcher_Vtbl { unsafe extern "system" fn CanAutomaticallyUpgradeService, Impl: IUpdateSearcher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -3845,7 +3845,7 @@ impl IUpdateSearcher_Vtbl { let this = (*this).get_impl(); this.SetServerSelection(::core::mem::transmute_copy(&value)).into() } - unsafe extern "system" fn BeginSearch, Impl: IUpdateSearcher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, criteria: ::std::mem::MaybeUninit<::windows_core::BSTR>, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BeginSearch, Impl: IUpdateSearcher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, criteria: ::std::mem::MaybeUninit<::windows_core::BSTR>, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BeginSearch(::core::mem::transmute(&criteria), ::windows_core::from_raw_borrowed(&oncompleted), ::core::mem::transmute(&state)) { @@ -3969,15 +3969,15 @@ impl IUpdateSearcher_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSearcher2_Impl: Sized + IUpdateSearcher_Impl { fn IgnoreDownloadPriority(&self) -> ::windows_core::Result; fn SetIgnoreDownloadPriority(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSearcher2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSearcher2_Vtbl { pub const fn new, Impl: IUpdateSearcher2_Impl, const OFFSET: isize>() -> IUpdateSearcher2_Vtbl { unsafe extern "system" fn IgnoreDownloadPriority, Impl: IUpdateSearcher2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4006,15 +4006,15 @@ impl IUpdateSearcher2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSearcher3_Impl: Sized + IUpdateSearcher2_Impl { fn SearchScope(&self) -> ::windows_core::Result; fn SetSearchScope(&self, value: SearchScope) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSearcher3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSearcher3_Vtbl { pub const fn new, Impl: IUpdateSearcher3_Impl, const OFFSET: isize>() -> IUpdateSearcher3_Vtbl { unsafe extern "system" fn SearchScope, Impl: IUpdateSearcher3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut SearchScope) -> ::windows_core::HRESULT { @@ -4043,11 +4043,11 @@ impl IUpdateSearcher3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateService_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn ContentValidationCert(&self) -> ::windows_core::Result; + fn ContentValidationCert(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn ExpirationDate(&self) -> ::windows_core::Result; fn IsManaged(&self) -> ::windows_core::Result; fn IsRegisteredWithAU(&self) -> ::windows_core::Result; @@ -4060,9 +4060,9 @@ pub trait IUpdateService_Impl: Sized + super::Com::IDispatch_Impl { fn ServiceUrl(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetupPrefix(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateService {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateService_Vtbl { pub const fn new, Impl: IUpdateService_Impl, const OFFSET: isize>() -> IUpdateService_Vtbl { unsafe extern "system" fn Name, Impl: IUpdateService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4076,7 +4076,7 @@ impl IUpdateService_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ContentValidationCert, Impl: IUpdateService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ContentValidationCert, Impl: IUpdateService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ContentValidationCert() { @@ -4229,14 +4229,14 @@ impl IUpdateService_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateService2_Impl: Sized + IUpdateService_Impl { fn IsDefaultAUService(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateService2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateService2_Vtbl { pub const fn new, Impl: IUpdateService2_Impl, const OFFSET: isize>() -> IUpdateService2_Vtbl { unsafe extern "system" fn IsDefaultAUService, Impl: IUpdateService2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -4256,16 +4256,16 @@ impl IUpdateService2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateServiceCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateServiceCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateServiceCollection_Vtbl { pub const fn new, Impl: IUpdateServiceCollection_Impl, const OFFSET: isize>() -> IUpdateServiceCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IUpdateServiceCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4312,8 +4312,8 @@ impl IUpdateServiceCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateServiceManager_Impl: Sized + super::Com::IDispatch_Impl { fn Services(&self) -> ::windows_core::Result; fn AddService(&self, serviceid: &::windows_core::BSTR, authorizationcabpath: &::windows_core::BSTR) -> ::windows_core::Result; @@ -4321,11 +4321,11 @@ pub trait IUpdateServiceManager_Impl: Sized + super::Com::IDispatch_Impl { fn RemoveService(&self, serviceid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn UnregisterServiceWithAU(&self, serviceid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn AddScanPackageService(&self, servicename: &::windows_core::BSTR, scanfilelocation: &::windows_core::BSTR, flags: i32) -> ::windows_core::Result; - fn SetOption(&self, optionname: &::windows_core::BSTR, optionvalue: &super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetOption(&self, optionname: &::windows_core::BSTR, optionvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateServiceManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateServiceManager_Vtbl { pub const fn new, Impl: IUpdateServiceManager_Impl, const OFFSET: isize>() -> IUpdateServiceManager_Vtbl { unsafe extern "system" fn Services, Impl: IUpdateServiceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4376,7 +4376,7 @@ impl IUpdateServiceManager_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetOption, Impl: IUpdateServiceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOption, Impl: IUpdateServiceManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOption(::core::mem::transmute(&optionname), ::core::mem::transmute(&optionvalue)).into() @@ -4396,17 +4396,17 @@ impl IUpdateServiceManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateServiceManager2_Impl: Sized + IUpdateServiceManager_Impl { fn ClientApplicationID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetClientApplicationID(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn QueryServiceRegistration(&self, serviceid: &::windows_core::BSTR) -> ::windows_core::Result; fn AddService2(&self, serviceid: &::windows_core::BSTR, flags: i32, authorizationcabpath: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateServiceManager2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateServiceManager2_Vtbl { pub const fn new, Impl: IUpdateServiceManager2_Impl, const OFFSET: isize>() -> IUpdateServiceManager2_Vtbl { unsafe extern "system" fn ClientApplicationID, Impl: IUpdateServiceManager2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4459,17 +4459,17 @@ impl IUpdateServiceManager2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateServiceRegistration_Impl: Sized + super::Com::IDispatch_Impl { fn RegistrationState(&self) -> ::windows_core::Result; fn ServiceID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IsPendingRegistrationWithAU(&self) -> ::windows_core::Result; fn Service(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateServiceRegistration {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateServiceRegistration_Vtbl { pub const fn new, Impl: IUpdateServiceRegistration_Impl, const OFFSET: isize>() -> IUpdateServiceRegistration_Vtbl { unsafe extern "system" fn RegistrationState, Impl: IUpdateServiceRegistration_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut UpdateServiceRegistrationState) -> ::windows_core::HRESULT { @@ -4528,8 +4528,8 @@ impl IUpdateServiceRegistration_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSession_Impl: Sized + super::Com::IDispatch_Impl { fn ClientApplicationID(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetClientApplicationID(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4540,9 +4540,9 @@ pub trait IUpdateSession_Impl: Sized + super::Com::IDispatch_Impl { fn CreateUpdateDownloader(&self) -> ::windows_core::Result; fn CreateUpdateInstaller(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSession {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSession_Vtbl { pub const fn new, Impl: IUpdateSession_Impl, const OFFSET: isize>() -> IUpdateSession_Vtbl { unsafe extern "system" fn ClientApplicationID, Impl: IUpdateSession_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4637,15 +4637,15 @@ impl IUpdateSession_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSession2_Impl: Sized + IUpdateSession_Impl { fn UserLocale(&self) -> ::windows_core::Result; fn SetUserLocale(&self, lcid: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSession2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSession2_Vtbl { pub const fn new, Impl: IUpdateSession2_Impl, const OFFSET: isize>() -> IUpdateSession2_Vtbl { unsafe extern "system" fn UserLocale, Impl: IUpdateSession2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut u32) -> ::windows_core::HRESULT { @@ -4674,15 +4674,15 @@ impl IUpdateSession2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUpdateSession3_Impl: Sized + IUpdateSession2_Impl { fn CreateUpdateServiceManager(&self) -> ::windows_core::Result; fn QueryHistory(&self, criteria: &::windows_core::BSTR, startindex: i32, count: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUpdateSession3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUpdateSession3_Vtbl { pub const fn new, Impl: IUpdateSession3_Impl, const OFFSET: isize>() -> IUpdateSession3_Vtbl { unsafe extern "system" fn CreateUpdateServiceManager, Impl: IUpdateSession3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4717,8 +4717,8 @@ impl IUpdateSession3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWebProxy_Impl: Sized + super::Com::IDispatch_Impl { fn Address(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAddress(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -4735,9 +4735,9 @@ pub trait IWebProxy_Impl: Sized + super::Com::IDispatch_Impl { fn AutoDetect(&self) -> ::windows_core::Result; fn SetAutoDetect(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWebProxy {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWebProxy_Vtbl { pub const fn new, Impl: IWebProxy_Impl, const OFFSET: isize>() -> IWebProxy_Vtbl { unsafe extern "system" fn Address, Impl: IWebProxy_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4868,8 +4868,8 @@ impl IWebProxy_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdate_Impl: Sized + IUpdate_Impl { fn DriverClass(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DriverHardwareID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -4880,9 +4880,9 @@ pub trait IWindowsDriverUpdate_Impl: Sized + IUpdate_Impl { fn DeviceProblemNumber(&self) -> ::windows_core::Result; fn DeviceStatus(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdate_Vtbl { pub const fn new, Impl: IWindowsDriverUpdate_Impl, const OFFSET: isize>() -> IWindowsDriverUpdate_Vtbl { unsafe extern "system" fn DriverClass, Impl: IWindowsDriverUpdate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4989,17 +4989,17 @@ impl IWindowsDriverUpdate_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdate2_Impl: Sized + IWindowsDriverUpdate_Impl { fn RebootRequired(&self) -> ::windows_core::Result; fn IsPresent(&self) -> ::windows_core::Result; fn CveIDs(&self) -> ::windows_core::Result; fn CopyToCache(&self, pfiles: ::core::option::Option<&IStringCollection>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdate2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdate2_Vtbl { pub const fn new, Impl: IWindowsDriverUpdate2_Impl, const OFFSET: isize>() -> IWindowsDriverUpdate2_Vtbl { unsafe extern "system" fn RebootRequired, Impl: IWindowsDriverUpdate2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5052,14 +5052,14 @@ impl IWindowsDriverUpdate2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdate3_Impl: Sized + IWindowsDriverUpdate2_Impl { fn BrowseOnly(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdate3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdate3_Vtbl { pub const fn new, Impl: IWindowsDriverUpdate3_Impl, const OFFSET: isize>() -> IWindowsDriverUpdate3_Vtbl { unsafe extern "system" fn BrowseOnly, Impl: IWindowsDriverUpdate3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -5079,15 +5079,15 @@ impl IWindowsDriverUpdate3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdate4_Impl: Sized + IWindowsDriverUpdate3_Impl { fn WindowsDriverUpdateEntries(&self) -> ::windows_core::Result; fn PerUser(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdate4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdate4_Vtbl { pub const fn new, Impl: IWindowsDriverUpdate4_Impl, const OFFSET: isize>() -> IWindowsDriverUpdate4_Vtbl { unsafe extern "system" fn WindowsDriverUpdateEntries, Impl: IWindowsDriverUpdate4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5122,15 +5122,15 @@ impl IWindowsDriverUpdate4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdate5_Impl: Sized + IWindowsDriverUpdate4_Impl { fn AutoSelection(&self) -> ::windows_core::Result; fn AutoDownload(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdate5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdate5_Vtbl { pub const fn new, Impl: IWindowsDriverUpdate5_Impl, const OFFSET: isize>() -> IWindowsDriverUpdate5_Vtbl { unsafe extern "system" fn AutoSelection, Impl: IWindowsDriverUpdate5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut AutoSelectionMode) -> ::windows_core::HRESULT { @@ -5165,8 +5165,8 @@ impl IWindowsDriverUpdate5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdateEntry_Impl: Sized + super::Com::IDispatch_Impl { fn DriverClass(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DriverHardwareID(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5177,9 +5177,9 @@ pub trait IWindowsDriverUpdateEntry_Impl: Sized + super::Com::IDispatch_Impl { fn DeviceProblemNumber(&self) -> ::windows_core::Result; fn DeviceStatus(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdateEntry {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdateEntry_Vtbl { pub const fn new, Impl: IWindowsDriverUpdateEntry_Impl, const OFFSET: isize>() -> IWindowsDriverUpdateEntry_Vtbl { unsafe extern "system" fn DriverClass, Impl: IWindowsDriverUpdateEntry_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5286,16 +5286,16 @@ impl IWindowsDriverUpdateEntry_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsDriverUpdateEntryCollection_Impl: Sized + super::Com::IDispatch_Impl { fn get_Item(&self, index: i32) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsDriverUpdateEntryCollection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsDriverUpdateEntryCollection_Vtbl { pub const fn new, Impl: IWindowsDriverUpdateEntryCollection_Impl, const OFFSET: isize>() -> IWindowsDriverUpdateEntryCollection_Vtbl { unsafe extern "system" fn get_Item, Impl: IWindowsDriverUpdateEntryCollection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5342,17 +5342,17 @@ impl IWindowsDriverUpdateEntryCollection_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWindowsUpdateAgentInfo_Impl: Sized + super::Com::IDispatch_Impl { - fn GetInfo(&self, varinfoidentifier: &super::Variant::VARIANT) -> ::windows_core::Result; + fn GetInfo(&self, varinfoidentifier: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWindowsUpdateAgentInfo {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWindowsUpdateAgentInfo_Vtbl { pub const fn new, Impl: IWindowsUpdateAgentInfo_Impl, const OFFSET: isize>() -> IWindowsUpdateAgentInfo_Vtbl { - unsafe extern "system" fn GetInfo, Impl: IWindowsUpdateAgentInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinfoidentifier: super::Variant::VARIANT, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetInfo, Impl: IWindowsUpdateAgentInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varinfoidentifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetInfo(::core::mem::transmute(&varinfoidentifier)) { diff --git a/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/mod.rs b/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/mod.rs index f86bd1fbaf..eef5d9e21f 100644 --- a/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/UpdateAgent/mod.rs @@ -115,15 +115,11 @@ pub struct IAutomaticUpdates2_Vtbl { ::windows_core::imp::interface_hierarchy!(IAutomaticUpdatesResults, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IAutomaticUpdatesResults { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastSearchSuccessDate(&self) -> ::windows_core::Result { + pub unsafe fn LastSearchSuccessDate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastSearchSuccessDate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LastInstallationSuccessDate(&self) -> ::windows_core::Result { + pub unsafe fn LastInstallationSuccessDate(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LastInstallationSuccessDate)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -133,14 +129,8 @@ impl IAutomaticUpdatesResults { #[doc(hidden)] pub struct IAutomaticUpdatesResults_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastSearchSuccessDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastSearchSuccessDate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LastInstallationSuccessDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LastInstallationSuccessDate: usize, + pub LastSearchSuccessDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub LastInstallationSuccessDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -537,9 +527,7 @@ pub struct IDownloadCompletedCallbackArgs_Vtbl { ::windows_core::imp::interface_hierarchy!(IDownloadJob, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IDownloadJob { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AsyncState(&self) -> ::windows_core::Result { + pub unsafe fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AsyncState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -571,10 +559,7 @@ impl IDownloadJob { #[doc(hidden)] pub struct IDownloadJob_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AsyncState: usize, + pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsCompleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Updates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -900,9 +885,7 @@ pub struct IInstallationCompletedCallbackArgs_Vtbl { ::windows_core::imp::interface_hierarchy!(IInstallationJob, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IInstallationJob { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AsyncState(&self) -> ::windows_core::Result { + pub unsafe fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AsyncState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -934,10 +917,7 @@ impl IInstallationJob { #[doc(hidden)] pub struct IInstallationJob_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AsyncState: usize, + pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsCompleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Updates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1171,9 +1151,7 @@ pub struct ISearchCompletedCallbackArgs_Vtbl { ::windows_core::imp::interface_hierarchy!(ISearchJob, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISearchJob { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AsyncState(&self) -> ::windows_core::Result { + pub unsafe fn AsyncState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AsyncState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1193,10 +1171,7 @@ impl ISearchJob { #[doc(hidden)] pub struct ISearchJob_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AsyncState: usize, + pub AsyncState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsCompleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub CleanUp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RequestAbort: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1395,9 +1370,7 @@ impl IUpdate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1600,10 +1573,7 @@ pub struct IUpdate_Vtbl { pub Categories: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Categories: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Deadline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Deadline: usize, + pub Deadline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DeltaCompressedContentAvailable: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub DeltaCompressedContentPreferred: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Description: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1712,9 +1682,7 @@ impl IUpdate2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1974,9 +1942,7 @@ impl IUpdate3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2231,9 +2197,7 @@ impl IUpdate4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2492,9 +2456,7 @@ impl IUpdate5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2993,15 +2955,16 @@ impl IUpdateDownloader { { (::windows_core::Interface::vtable(self).SetUpdates)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginDownload(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginDownload(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BeginDownload)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BeginDownload)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3038,9 +3001,9 @@ pub struct IUpdateDownloader_Vtbl { pub SetUpdates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SetUpdates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BeginDownload: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub BeginDownload: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] BeginDownload: usize, #[cfg(feature = "Win32_System_Com")] pub Download: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3472,25 +3435,27 @@ impl IUpdateInstaller { { (::windows_core::Interface::vtable(self).SetUpdates)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3571,13 +3536,13 @@ pub struct IUpdateInstaller_Vtbl { pub SetUpdates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SetUpdates: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BeginInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub BeginInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] BeginInstall: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BeginUninstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub BeginUninstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, onprogresschanged: *mut ::core::ffi::c_void, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] BeginUninstall: usize, #[cfg(feature = "Win32_System_Com")] pub EndInstall: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3669,25 +3634,27 @@ impl IUpdateInstaller2 { { (::windows_core::Interface::vtable(self).base__.SetUpdates)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3830,25 +3797,27 @@ impl IUpdateInstaller3 { { (::windows_core::Interface::vtable(self).base__.base__.SetUpdates)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4001,25 +3970,27 @@ impl IUpdateInstaller4 { { (::windows_core::Interface::vtable(self).base__.base__.base__.SetUpdates)(::windows_core::Interface::as_raw(self), value.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginInstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.BeginInstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginUninstall(&self, onprogresschanged: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.BeginUninstall)(::windows_core::Interface::as_raw(self), onprogresschanged.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4170,15 +4141,16 @@ impl IUpdateSearcher { pub unsafe fn SetServerSelection(&self, value: ServerSelection) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetServerSelection)(::windows_core::Interface::as_raw(self), value).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4249,9 +4221,9 @@ pub struct IUpdateSearcher_Vtbl { pub SetIncludePotentiallySupersededUpdates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub ServerSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ServerSelection) -> ::windows_core::HRESULT, pub SetServerSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ServerSelection) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BeginSearch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, criteria: ::std::mem::MaybeUninit<::windows_core::BSTR>, oncompleted: *mut ::core::ffi::c_void, state: super::Variant::VARIANT, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub BeginSearch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, criteria: ::std::mem::MaybeUninit<::windows_core::BSTR>, oncompleted: *mut ::core::ffi::c_void, state: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] BeginSearch: usize, #[cfg(feature = "Win32_System_Com")] pub EndSearch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, searchjob: *mut ::core::ffi::c_void, retval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4320,15 +4292,16 @@ impl IUpdateSearcher2 { pub unsafe fn SetServerSelection(&self, value: ServerSelection) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.SetServerSelection)(::windows_core::Interface::as_raw(self), value).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4452,15 +4425,16 @@ impl IUpdateSearcher3 { pub unsafe fn SetServerSelection(&self, value: ServerSelection) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.SetServerSelection)(::windows_core::Interface::as_raw(self), value).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: super::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BeginSearch(&self, criteria: P0, oncompleted: P1, state: P2) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), ::core::mem::transmute(state), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.BeginSearch)(::windows_core::Interface::as_raw(self), criteria.into_param().abi(), oncompleted.into_param().abi(), state.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4558,9 +4532,7 @@ impl IUpdateService { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ContentValidationCert(&self) -> ::windows_core::Result { + pub unsafe fn ContentValidationCert(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ContentValidationCert)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4617,10 +4589,7 @@ impl IUpdateService { pub struct IUpdateService_Vtbl { pub base__: super::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ContentValidationCert: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ContentValidationCert: usize, + pub ContentValidationCert: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ExpirationDate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut f64) -> ::windows_core::HRESULT, pub IsManaged: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub IsRegisteredWithAU: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -4651,9 +4620,7 @@ impl IUpdateService2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ContentValidationCert(&self) -> ::windows_core::Result { + pub unsafe fn ContentValidationCert(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ContentValidationCert)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4808,13 +4775,12 @@ impl IUpdateServiceManager { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AddScanPackageService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), scanfilelocation.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, optionname: P0, optionvalue: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetOption(&self, optionname: P0, optionvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), ::core::mem::transmute(optionvalue)).ok() + (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), optionvalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -4837,10 +4803,7 @@ pub struct IUpdateServiceManager_Vtbl { pub AddScanPackageService: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, scanfilelocation: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: i32, ppservice: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddScanPackageService: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOption: usize, + pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionname: ::std::mem::MaybeUninit<::windows_core::BSTR>, optionvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4897,13 +4860,12 @@ impl IUpdateServiceManager2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.AddScanPackageService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), scanfilelocation.into_param().abi(), flags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, optionname: P0, optionvalue: super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetOption(&self, optionname: P0, optionvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.SetOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), ::core::mem::transmute(optionvalue)).ok() + (::windows_core::Interface::vtable(self).base__.SetOption)(::windows_core::Interface::as_raw(self), optionname.into_param().abi(), optionvalue.into_param().abi()).ok() } pub unsafe fn ClientApplicationID(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -5399,9 +5361,7 @@ impl IWindowsDriverUpdate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5669,9 +5629,7 @@ impl IWindowsDriverUpdate2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5963,9 +5921,7 @@ impl IWindowsDriverUpdate3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6252,9 +6208,7 @@ impl IWindowsDriverUpdate4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6555,9 +6509,7 @@ impl IWindowsDriverUpdate5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Categories)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Deadline(&self) -> ::windows_core::Result { + pub unsafe fn Deadline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Deadline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -6935,11 +6887,12 @@ pub struct IWindowsDriverUpdateEntryCollection_Vtbl { ::windows_core::imp::interface_hierarchy!(IWindowsUpdateAgentInfo, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IWindowsUpdateAgentInfo { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetInfo(&self, varinfoidentifier: super::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetInfo(&self, varinfoidentifier: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetInfo)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varinfoidentifier), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetInfo)(::windows_core::Interface::as_raw(self), varinfoidentifier.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -6947,10 +6900,7 @@ impl IWindowsUpdateAgentInfo { #[doc(hidden)] pub struct IWindowsUpdateAgentInfo_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinfoidentifier: super::Variant::VARIANT, retval: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetInfo: usize, + pub GetInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varinfoidentifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } pub const AutomaticUpdates: ::windows_core::GUID = ::windows_core::GUID::from_u128(0xbfe18e9c_6d87_4450_b37c_e02f0b373803); pub const InstallationAgent: ::windows_core::GUID = ::windows_core::GUID::from_u128(0x317e92fc_1679_46fd_a0b5_f08914dd8623); diff --git a/crates/libs/windows/src/Windows/Win32/System/Variant/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Variant/mod.rs index fd25134e00..5160e68147 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Variant/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Variant/mod.rs @@ -1,8 +1,6 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn ClearVariantArray(pvars: &mut [VARIANT]) { - ::windows_targets::link!("propsys.dll" "system" fn ClearVariantArray(pvars : *mut VARIANT, cvars : u32)); +pub unsafe fn ClearVariantArray(pvars: &mut [::windows_core::VARIANT]) { + ::windows_targets::link!("propsys.dll" "system" fn ClearVariantArray(pvars : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, cvars : u32)); ClearVariantArray(::core::mem::transmute(pvars.as_ptr()), pvars.len().try_into().unwrap()) } #[inline] @@ -10,316 +8,236 @@ pub unsafe fn DosDateTimeToVariantTime(wdosdate: u16, wdostime: u16, pvtime: *mu ::windows_targets::link!("oleaut32.dll" "system" fn DosDateTimeToVariantTime(wdosdate : u16, wdostime : u16, pvtime : *mut f64) -> i32); DosDateTimeToVariantTime(wdosdate, wdostime, pvtime) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromBooleanArray(prgf: &[super::super::Foundation::BOOL]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromBooleanArray(prgf : *const super::super::Foundation:: BOOL, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromBooleanArray(prgf: &[super::super::Foundation::BOOL]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromBooleanArray(prgf : *const super::super::Foundation:: BOOL, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromBooleanArray(::core::mem::transmute(prgf.as_ptr()), prgf.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromBuffer(pv: *const ::core::ffi::c_void, cb: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromBuffer(pv : *const ::core::ffi::c_void, cb : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromBuffer(pv: *const ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromBuffer(pv : *const ::core::ffi::c_void, cb : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromBuffer(pv, cb, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromDoubleArray(prgn: &[f64]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromDoubleArray(prgn : *const f64, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromDoubleArray(prgn: &[f64]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromDoubleArray(prgn : *const f64, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromDoubleArray(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromFileTime(pft: *const super::super::Foundation::FILETIME) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromFileTime(pft : *const super::super::Foundation:: FILETIME, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromFileTime(pft: *const super::super::Foundation::FILETIME) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromFileTime(pft : *const super::super::Foundation:: FILETIME, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromFileTime(pft, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromFileTimeArray(prgft: ::core::option::Option<&[super::super::Foundation::FILETIME]>) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromFileTimeArray(prgft : *const super::super::Foundation:: FILETIME, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromFileTimeArray(prgft: ::core::option::Option<&[super::super::Foundation::FILETIME]>) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromFileTimeArray(prgft : *const super::super::Foundation:: FILETIME, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromFileTimeArray(::core::mem::transmute(prgft.as_deref().map_or(::core::ptr::null(), |slice| slice.as_ptr())), prgft.as_deref().map_or(0, |slice| slice.len().try_into().unwrap()), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromGUIDAsString(guid: *const ::windows_core::GUID) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromGUIDAsString(guid : *const ::windows_core::GUID, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromGUIDAsString(guid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromGUIDAsString(guid : *const ::windows_core::GUID, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromGUIDAsString(guid, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromInt16Array(prgn: &[i16]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt16Array(prgn : *const i16, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromInt16Array(prgn: &[i16]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt16Array(prgn : *const i16, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromInt16Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromInt32Array(prgn: &[i32]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt32Array(prgn : *const i32, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromInt32Array(prgn: &[i32]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt32Array(prgn : *const i32, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromInt32Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromInt64Array(prgn: &[i64]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt64Array(prgn : *const i64, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromInt64Array(prgn: &[i64]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromInt64Array(prgn : *const i64, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromInt64Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromResource(hinst: P0, id: u32) -> ::windows_core::Result +pub unsafe fn InitVariantFromResource(hinst: P0, id: u32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromResource(hinst : super::super::Foundation:: HINSTANCE, id : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromResource(hinst : super::super::Foundation:: HINSTANCE, id : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromResource(hinst.into_param().abi(), id, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromStringArray(prgsz: &[::windows_core::PCWSTR]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromStringArray(prgsz : *const ::windows_core::PCWSTR, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromStringArray(prgsz: &[::windows_core::PCWSTR]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromStringArray(prgsz : *const ::windows_core::PCWSTR, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromStringArray(::core::mem::transmute(prgsz.as_ptr()), prgsz.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromUInt16Array(prgn: &[u16]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt16Array(prgn : *const u16, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromUInt16Array(prgn: &[u16]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt16Array(prgn : *const u16, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromUInt16Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromUInt32Array(prgn: &[u32]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt32Array(prgn : *const u32, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromUInt32Array(prgn: &[u32]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt32Array(prgn : *const u32, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromUInt32Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromUInt64Array(prgn: &[u64]) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt64Array(prgn : *const u64, celems : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromUInt64Array(prgn: &[u64]) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromUInt64Array(prgn : *const u64, celems : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromUInt64Array(::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn InitVariantFromVariantArrayElem(varin: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromVariantArrayElem(varin : *const VARIANT, ielem : u32, pvar : *mut VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromVariantArrayElem(varin: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromVariantArrayElem(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - InitVariantFromVariantArrayElem(varin, ielem, &mut result__).from_abi(result__) + InitVariantFromVariantArrayElem(::core::mem::transmute(varin), ielem, &mut result__).from_abi(result__) } #[inline] pub unsafe fn SystemTimeToVariantTime(lpsystemtime: *const super::super::Foundation::SYSTEMTIME, pvtime: *mut f64) -> i32 { ::windows_targets::link!("oleaut32.dll" "system" fn SystemTimeToVariantTime(lpsystemtime : *const super::super::Foundation:: SYSTEMTIME, pvtime : *mut f64) -> i32); SystemTimeToVariantTime(lpsystemtime, pvtime) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserFree(param0: *const u32, param1: *const VARIANT) { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserFree(param0 : *const u32, param1 : *const VARIANT)); - VARIANT_UserFree(param0, param1) +pub unsafe fn VARIANT_UserFree(param0: *const u32, param1: *const ::windows_core::VARIANT) { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserFree(param0 : *const u32, param1 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >)); + VARIANT_UserFree(param0, ::core::mem::transmute(param1)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserFree64(param0: *const u32, param1: *const VARIANT) { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserFree64(param0 : *const u32, param1 : *const VARIANT)); - VARIANT_UserFree64(param0, param1) +pub unsafe fn VARIANT_UserFree64(param0: *const u32, param1: *const ::windows_core::VARIANT) { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserFree64(param0 : *const u32, param1 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >)); + VARIANT_UserFree64(param0, ::core::mem::transmute(param1)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserMarshal(param0: *const u32, param1: *mut u8, param2: *const VARIANT) -> *mut u8 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserMarshal(param0 : *const u32, param1 : *mut u8, param2 : *const VARIANT) -> *mut u8); - VARIANT_UserMarshal(param0, param1, param2) +pub unsafe fn VARIANT_UserMarshal(param0: *const u32, param1: *mut u8, param2: *const ::windows_core::VARIANT) -> *mut u8 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserMarshal(param0 : *const u32, param1 : *mut u8, param2 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> *mut u8); + VARIANT_UserMarshal(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserMarshal64(param0: *const u32, param1: *mut u8, param2: *const VARIANT) -> *mut u8 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserMarshal64(param0 : *const u32, param1 : *mut u8, param2 : *const VARIANT) -> *mut u8); - VARIANT_UserMarshal64(param0, param1, param2) +pub unsafe fn VARIANT_UserMarshal64(param0: *const u32, param1: *mut u8, param2: *const ::windows_core::VARIANT) -> *mut u8 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserMarshal64(param0 : *const u32, param1 : *mut u8, param2 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> *mut u8); + VARIANT_UserMarshal64(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserSize(param0: *const u32, param1: u32, param2: *const VARIANT) -> u32 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserSize(param0 : *const u32, param1 : u32, param2 : *const VARIANT) -> u32); - VARIANT_UserSize(param0, param1, param2) +pub unsafe fn VARIANT_UserSize(param0: *const u32, param1: u32, param2: *const ::windows_core::VARIANT) -> u32 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserSize(param0 : *const u32, param1 : u32, param2 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> u32); + VARIANT_UserSize(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserSize64(param0: *const u32, param1: u32, param2: *const VARIANT) -> u32 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserSize64(param0 : *const u32, param1 : u32, param2 : *const VARIANT) -> u32); - VARIANT_UserSize64(param0, param1, param2) +pub unsafe fn VARIANT_UserSize64(param0: *const u32, param1: u32, param2: *const ::windows_core::VARIANT) -> u32 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserSize64(param0 : *const u32, param1 : u32, param2 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> u32); + VARIANT_UserSize64(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserUnmarshal(param0: *const u32, param1: *const u8, param2: *mut VARIANT) -> *mut u8 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserUnmarshal(param0 : *const u32, param1 : *const u8, param2 : *mut VARIANT) -> *mut u8); - VARIANT_UserUnmarshal(param0, param1, param2) +pub unsafe fn VARIANT_UserUnmarshal(param0: *const u32, param1: *const u8, param2: *mut ::windows_core::VARIANT) -> *mut u8 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserUnmarshal(param0 : *const u32, param1 : *const u8, param2 : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> *mut u8); + VARIANT_UserUnmarshal(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VARIANT_UserUnmarshal64(param0: *const u32, param1: *const u8, param2: *mut VARIANT) -> *mut u8 { - ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserUnmarshal64(param0 : *const u32, param1 : *const u8, param2 : *mut VARIANT) -> *mut u8); - VARIANT_UserUnmarshal64(param0, param1, param2) +pub unsafe fn VARIANT_UserUnmarshal64(param0: *const u32, param1: *const u8, param2: *mut ::windows_core::VARIANT) -> *mut u8 { + ::windows_targets::link!("oleaut32.dll" "system" fn VARIANT_UserUnmarshal64(param0 : *const u32, param1 : *const u8, param2 : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> *mut u8); + VARIANT_UserUnmarshal64(param0, param1, ::core::mem::transmute(param2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantChangeType(pvargdest: *mut VARIANT, pvarsrc: *const VARIANT, wflags: VAR_CHANGE_FLAGS, vt: VARENUM) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantChangeType(pvargdest : *mut VARIANT, pvarsrc : *const VARIANT, wflags : VAR_CHANGE_FLAGS, vt : VARENUM) -> ::windows_core::HRESULT); - VariantChangeType(pvargdest, pvarsrc, wflags, vt).ok() +pub unsafe fn VariantChangeType(pvargdest: *mut ::windows_core::VARIANT, pvarsrc: *const ::windows_core::VARIANT, wflags: VAR_CHANGE_FLAGS, vt: VARENUM) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantChangeType(pvargdest : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarsrc : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, wflags : VAR_CHANGE_FLAGS, vt : VARENUM) -> ::windows_core::HRESULT); + VariantChangeType(::core::mem::transmute(pvargdest), ::core::mem::transmute(pvarsrc), wflags, vt).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantChangeTypeEx(pvargdest: *mut VARIANT, pvarsrc: *const VARIANT, lcid: u32, wflags: VAR_CHANGE_FLAGS, vt: VARENUM) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantChangeTypeEx(pvargdest : *mut VARIANT, pvarsrc : *const VARIANT, lcid : u32, wflags : VAR_CHANGE_FLAGS, vt : VARENUM) -> ::windows_core::HRESULT); - VariantChangeTypeEx(pvargdest, pvarsrc, lcid, wflags, vt).ok() +pub unsafe fn VariantChangeTypeEx(pvargdest: *mut ::windows_core::VARIANT, pvarsrc: *const ::windows_core::VARIANT, lcid: u32, wflags: VAR_CHANGE_FLAGS, vt: VARENUM) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantChangeTypeEx(pvargdest : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvarsrc : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, lcid : u32, wflags : VAR_CHANGE_FLAGS, vt : VARENUM) -> ::windows_core::HRESULT); + VariantChangeTypeEx(::core::mem::transmute(pvargdest), ::core::mem::transmute(pvarsrc), lcid, wflags, vt).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantClear(pvarg: *mut VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantClear(pvarg : *mut VARIANT) -> ::windows_core::HRESULT); - VariantClear(pvarg).ok() +pub unsafe fn VariantClear(pvarg: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantClear(pvarg : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + VariantClear(::core::mem::transmute(pvarg)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantCompare(var1: *const VARIANT, var2: *const VARIANT) -> i32 { - ::windows_targets::link!("propsys.dll" "system" fn VariantCompare(var1 : *const VARIANT, var2 : *const VARIANT) -> i32); - VariantCompare(var1, var2) +pub unsafe fn VariantCompare(var1: *const ::windows_core::VARIANT, var2: *const ::windows_core::VARIANT) -> i32 { + ::windows_targets::link!("propsys.dll" "system" fn VariantCompare(var1 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, var2 : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> i32); + VariantCompare(::core::mem::transmute(var1), ::core::mem::transmute(var2)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantCopy(pvargdest: *mut VARIANT, pvargsrc: *const VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantCopy(pvargdest : *mut VARIANT, pvargsrc : *const VARIANT) -> ::windows_core::HRESULT); - VariantCopy(pvargdest, pvargsrc).ok() +pub unsafe fn VariantCopy(pvargdest: *mut ::windows_core::VARIANT, pvargsrc: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantCopy(pvargdest : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvargsrc : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + VariantCopy(::core::mem::transmute(pvargdest), ::core::mem::transmute(pvargsrc)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantCopyInd(pvardest: *mut VARIANT, pvargsrc: *const VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantCopyInd(pvardest : *mut VARIANT, pvargsrc : *const VARIANT) -> ::windows_core::HRESULT); - VariantCopyInd(pvardest, pvargsrc).ok() +pub unsafe fn VariantCopyInd(pvardest: *mut ::windows_core::VARIANT, pvargsrc: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantCopyInd(pvardest : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pvargsrc : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + VariantCopyInd(::core::mem::transmute(pvardest), ::core::mem::transmute(pvargsrc)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetBooleanElem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetBooleanElem(var : *const VARIANT, ielem : u32, pfval : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetBooleanElem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetBooleanElem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pfval : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetBooleanElem(var, ielem, &mut result__).from_abi(result__) + VariantGetBooleanElem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetDoubleElem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetDoubleElem(var : *const VARIANT, ielem : u32, pnval : *mut f64) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetDoubleElem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetDoubleElem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut f64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetDoubleElem(var, ielem, &mut result__).from_abi(result__) + VariantGetDoubleElem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetElementCount(varin: *const VARIANT) -> u32 { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetElementCount(varin : *const VARIANT) -> u32); - VariantGetElementCount(varin) +pub unsafe fn VariantGetElementCount(varin: *const ::windows_core::VARIANT) -> u32 { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetElementCount(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> u32); + VariantGetElementCount(::core::mem::transmute(varin)) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetInt16Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt16Elem(var : *const VARIANT, ielem : u32, pnval : *mut i16) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetInt16Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt16Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut i16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetInt16Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetInt16Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetInt32Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt32Elem(var : *const VARIANT, ielem : u32, pnval : *mut i32) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetInt32Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt32Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut i32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetInt32Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetInt32Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetInt64Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt64Elem(var : *const VARIANT, ielem : u32, pnval : *mut i64) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetInt64Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetInt64Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut i64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetInt64Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetInt64Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetStringElem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetStringElem(var : *const VARIANT, ielem : u32, ppszval : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetStringElem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetStringElem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, ppszval : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetStringElem(var, ielem, &mut result__).from_abi(result__) + VariantGetStringElem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetUInt16Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt16Elem(var : *const VARIANT, ielem : u32, pnval : *mut u16) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetUInt16Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt16Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut u16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetUInt16Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetUInt16Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetUInt32Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt32Elem(var : *const VARIANT, ielem : u32, pnval : *mut u32) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetUInt32Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt32Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut u32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetUInt32Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetUInt32Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantGetUInt64Elem(var: *const VARIANT, ielem: u32) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt64Elem(var : *const VARIANT, ielem : u32, pnval : *mut u64) -> ::windows_core::HRESULT); +pub unsafe fn VariantGetUInt64Elem(var: *const ::windows_core::VARIANT, ielem: u32) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantGetUInt64Elem(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ielem : u32, pnval : *mut u64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantGetUInt64Elem(var, ielem, &mut result__).from_abi(result__) + VariantGetUInt64Elem(::core::mem::transmute(var), ielem, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantInit() -> VARIANT { - ::windows_targets::link!("oleaut32.dll" "system" fn VariantInit(pvarg : *mut VARIANT)); +pub unsafe fn VariantInit() -> ::windows_core::VARIANT { + ::windows_targets::link!("oleaut32.dll" "system" fn VariantInit(pvarg : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >)); let mut result__ = ::std::mem::zeroed(); VariantInit(&mut result__); ::std::mem::transmute(result__) @@ -334,309 +252,227 @@ pub unsafe fn VariantTimeToSystemTime(vtime: f64, lpsystemtime: *mut super::supe ::windows_targets::link!("oleaut32.dll" "system" fn VariantTimeToSystemTime(vtime : f64, lpsystemtime : *mut super::super::Foundation:: SYSTEMTIME) -> i32); VariantTimeToSystemTime(vtime, lpsystemtime) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToBoolean(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToBoolean(varin : *const VARIANT, pfret : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); +pub unsafe fn VariantToBoolean(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToBoolean(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pfret : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToBoolean(varin, &mut result__).from_abi(result__) + VariantToBoolean(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToBooleanArray(var: *const VARIANT, prgf: &mut [super::super::Foundation::BOOL], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanArray(var : *const VARIANT, prgf : *mut super::super::Foundation:: BOOL, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToBooleanArray(var, ::core::mem::transmute(prgf.as_ptr()), prgf.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToBooleanArray(var: *const ::windows_core::VARIANT, prgf: &mut [super::super::Foundation::BOOL], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanArray(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgf : *mut super::super::Foundation:: BOOL, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToBooleanArray(::core::mem::transmute(var), ::core::mem::transmute(prgf.as_ptr()), prgf.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToBooleanArrayAlloc(var: *const VARIANT, pprgf: *mut *mut super::super::Foundation::BOOL, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanArrayAlloc(var : *const VARIANT, pprgf : *mut *mut super::super::Foundation:: BOOL, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToBooleanArrayAlloc(var, pprgf, pcelem).ok() +pub unsafe fn VariantToBooleanArrayAlloc(var: *const ::windows_core::VARIANT, pprgf: *mut *mut super::super::Foundation::BOOL, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgf : *mut *mut super::super::Foundation:: BOOL, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToBooleanArrayAlloc(::core::mem::transmute(var), pprgf, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToBooleanWithDefault(varin: *const VARIANT, fdefault: P0) -> super::super::Foundation::BOOL +pub unsafe fn VariantToBooleanWithDefault(varin: *const ::windows_core::VARIANT, fdefault: P0) -> super::super::Foundation::BOOL where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanWithDefault(varin : *const VARIANT, fdefault : super::super::Foundation:: BOOL) -> super::super::Foundation:: BOOL); - VariantToBooleanWithDefault(varin, fdefault.into_param().abi()) + ::windows_targets::link!("propsys.dll" "system" fn VariantToBooleanWithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, fdefault : super::super::Foundation:: BOOL) -> super::super::Foundation:: BOOL); + VariantToBooleanWithDefault(::core::mem::transmute(varin), fdefault.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToBuffer(varin: *const VARIANT, pv: *mut ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToBuffer(varin : *const VARIANT, pv : *mut ::core::ffi::c_void, cb : u32) -> ::windows_core::HRESULT); - VariantToBuffer(varin, pv, cb).ok() +pub unsafe fn VariantToBuffer(varin: *const ::windows_core::VARIANT, pv: *mut ::core::ffi::c_void, cb: u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToBuffer(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pv : *mut ::core::ffi::c_void, cb : u32) -> ::windows_core::HRESULT); + VariantToBuffer(::core::mem::transmute(varin), pv, cb).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToDosDateTime(varin: *const VARIANT, pwdate: *mut u16, pwtime: *mut u16) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToDosDateTime(varin : *const VARIANT, pwdate : *mut u16, pwtime : *mut u16) -> ::windows_core::HRESULT); - VariantToDosDateTime(varin, pwdate, pwtime).ok() +pub unsafe fn VariantToDosDateTime(varin: *const ::windows_core::VARIANT, pwdate: *mut u16, pwtime: *mut u16) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToDosDateTime(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pwdate : *mut u16, pwtime : *mut u16) -> ::windows_core::HRESULT); + VariantToDosDateTime(::core::mem::transmute(varin), pwdate, pwtime).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToDouble(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToDouble(varin : *const VARIANT, pdblret : *mut f64) -> ::windows_core::HRESULT); +pub unsafe fn VariantToDouble(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToDouble(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pdblret : *mut f64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToDouble(varin, &mut result__).from_abi(result__) + VariantToDouble(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToDoubleArray(var: *const VARIANT, prgn: &mut [f64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleArray(var : *const VARIANT, prgn : *mut f64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToDoubleArray(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToDoubleArray(var: *const ::windows_core::VARIANT, prgn: &mut [f64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleArray(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut f64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToDoubleArray(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToDoubleArrayAlloc(var: *const VARIANT, pprgn: *mut *mut f64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleArrayAlloc(var : *const VARIANT, pprgn : *mut *mut f64, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToDoubleArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToDoubleArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut f64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut f64, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToDoubleArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToDoubleWithDefault(varin: *const VARIANT, dbldefault: f64) -> f64 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleWithDefault(varin : *const VARIANT, dbldefault : f64) -> f64); - VariantToDoubleWithDefault(varin, dbldefault) +pub unsafe fn VariantToDoubleWithDefault(varin: *const ::windows_core::VARIANT, dbldefault: f64) -> f64 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToDoubleWithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, dbldefault : f64) -> f64); + VariantToDoubleWithDefault(::core::mem::transmute(varin), dbldefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToFileTime(varin: *const VARIANT, stfout: PSTIME_FLAGS) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToFileTime(varin : *const VARIANT, stfout : PSTIME_FLAGS, pftout : *mut super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); +pub unsafe fn VariantToFileTime(varin: *const ::windows_core::VARIANT, stfout: PSTIME_FLAGS) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToFileTime(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, stfout : PSTIME_FLAGS, pftout : *mut super::super::Foundation:: FILETIME) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToFileTime(varin, stfout, &mut result__).from_abi(result__) + VariantToFileTime(::core::mem::transmute(varin), stfout, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToGUID(varin: *const VARIANT) -> ::windows_core::Result<::windows_core::GUID> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToGUID(varin : *const VARIANT, pguid : *mut ::windows_core::GUID) -> ::windows_core::HRESULT); +pub unsafe fn VariantToGUID(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::GUID> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToGUID(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pguid : *mut ::windows_core::GUID) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToGUID(varin, &mut result__).from_abi(result__) + VariantToGUID(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt16(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16(varin : *const VARIANT, piret : *mut i16) -> ::windows_core::HRESULT); +pub unsafe fn VariantToInt16(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, piret : *mut i16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToInt16(varin, &mut result__).from_abi(result__) + VariantToInt16(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt16Array(var: *const VARIANT, prgn: &mut [i16], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16Array(var : *const VARIANT, prgn : *mut i16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt16Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToInt16Array(var: *const ::windows_core::VARIANT, prgn: &mut [i16], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut i16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt16Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt16ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut i16, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut i16, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt16ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToInt16ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut i16, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut i16, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt16ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt16WithDefault(varin: *const VARIANT, idefault: i16) -> i16 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16WithDefault(varin : *const VARIANT, idefault : i16) -> i16); - VariantToInt16WithDefault(varin, idefault) +pub unsafe fn VariantToInt16WithDefault(varin: *const ::windows_core::VARIANT, idefault: i16) -> i16 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt16WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, idefault : i16) -> i16); + VariantToInt16WithDefault(::core::mem::transmute(varin), idefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt32(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32(varin : *const VARIANT, plret : *mut i32) -> ::windows_core::HRESULT); +pub unsafe fn VariantToInt32(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, plret : *mut i32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToInt32(varin, &mut result__).from_abi(result__) + VariantToInt32(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt32Array(var: *const VARIANT, prgn: &mut [i32], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32Array(var : *const VARIANT, prgn : *mut i32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt32Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToInt32Array(var: *const ::windows_core::VARIANT, prgn: &mut [i32], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut i32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt32Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt32ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut i32, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut i32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt32ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToInt32ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut i32, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut i32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt32ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt32WithDefault(varin: *const VARIANT, ldefault: i32) -> i32 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32WithDefault(varin : *const VARIANT, ldefault : i32) -> i32); - VariantToInt32WithDefault(varin, ldefault) +pub unsafe fn VariantToInt32WithDefault(varin: *const ::windows_core::VARIANT, ldefault: i32) -> i32 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt32WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ldefault : i32) -> i32); + VariantToInt32WithDefault(::core::mem::transmute(varin), ldefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt64(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64(varin : *const VARIANT, pllret : *mut i64) -> ::windows_core::HRESULT); +pub unsafe fn VariantToInt64(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pllret : *mut i64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToInt64(varin, &mut result__).from_abi(result__) + VariantToInt64(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt64Array(var: *const VARIANT, prgn: &mut [i64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64Array(var : *const VARIANT, prgn : *mut i64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt64Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToInt64Array(var: *const ::windows_core::VARIANT, prgn: &mut [i64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut i64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt64Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt64ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut i64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut i64, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToInt64ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToInt64ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut i64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut i64, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToInt64ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToInt64WithDefault(varin: *const VARIANT, lldefault: i64) -> i64 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64WithDefault(varin : *const VARIANT, lldefault : i64) -> i64); - VariantToInt64WithDefault(varin, lldefault) +pub unsafe fn VariantToInt64WithDefault(varin: *const ::windows_core::VARIANT, lldefault: i64) -> i64 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToInt64WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, lldefault : i64) -> i64); + VariantToInt64WithDefault(::core::mem::transmute(varin), lldefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToString(varin: *const VARIANT, pszbuf: &mut [u16]) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToString(varin : *const VARIANT, pszbuf : ::windows_core::PWSTR, cchbuf : u32) -> ::windows_core::HRESULT); - VariantToString(varin, ::core::mem::transmute(pszbuf.as_ptr()), pszbuf.len().try_into().unwrap()).ok() +pub unsafe fn VariantToString(varin: *const ::windows_core::VARIANT, pszbuf: &mut [u16]) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToString(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pszbuf : ::windows_core::PWSTR, cchbuf : u32) -> ::windows_core::HRESULT); + VariantToString(::core::mem::transmute(varin), ::core::mem::transmute(pszbuf.as_ptr()), pszbuf.len().try_into().unwrap()).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToStringAlloc(varin: *const VARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToStringAlloc(varin : *const VARIANT, ppszbuf : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn VariantToStringAlloc(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToStringAlloc(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ppszbuf : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToStringAlloc(varin, &mut result__).from_abi(result__) + VariantToStringAlloc(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToStringArray(var: *const VARIANT, prgsz: &mut [::windows_core::PWSTR], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToStringArray(var : *const VARIANT, prgsz : *mut ::windows_core::PWSTR, crgsz : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToStringArray(var, ::core::mem::transmute(prgsz.as_ptr()), prgsz.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToStringArray(var: *const ::windows_core::VARIANT, prgsz: &mut [::windows_core::PWSTR], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToStringArray(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgsz : *mut ::windows_core::PWSTR, crgsz : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToStringArray(::core::mem::transmute(var), ::core::mem::transmute(prgsz.as_ptr()), prgsz.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToStringArrayAlloc(var: *const VARIANT, pprgsz: *mut *mut ::windows_core::PWSTR, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToStringArrayAlloc(var : *const VARIANT, pprgsz : *mut *mut ::windows_core::PWSTR, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToStringArrayAlloc(var, pprgsz, pcelem).ok() +pub unsafe fn VariantToStringArrayAlloc(var: *const ::windows_core::VARIANT, pprgsz: *mut *mut ::windows_core::PWSTR, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToStringArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgsz : *mut *mut ::windows_core::PWSTR, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToStringArrayAlloc(::core::mem::transmute(var), pprgsz, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToStringWithDefault(varin: *const VARIANT, pszdefault: P0) -> ::windows_core::PCWSTR +pub unsafe fn VariantToStringWithDefault(varin: *const ::windows_core::VARIANT, pszdefault: P0) -> ::windows_core::PCWSTR where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("propsys.dll" "system" fn VariantToStringWithDefault(varin : *const VARIANT, pszdefault : ::windows_core::PCWSTR) -> ::windows_core::PCWSTR); - VariantToStringWithDefault(varin, pszdefault.into_param().abi()) + ::windows_targets::link!("propsys.dll" "system" fn VariantToStringWithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pszdefault : ::windows_core::PCWSTR) -> ::windows_core::PCWSTR); + VariantToStringWithDefault(::core::mem::transmute(varin), pszdefault.into_param().abi()) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt16(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16(varin : *const VARIANT, puiret : *mut u16) -> ::windows_core::HRESULT); +pub unsafe fn VariantToUInt16(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, puiret : *mut u16) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToUInt16(varin, &mut result__).from_abi(result__) + VariantToUInt16(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt16Array(var: *const VARIANT, prgn: &mut [u16], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16Array(var : *const VARIANT, prgn : *mut u16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt16Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToUInt16Array(var: *const ::windows_core::VARIANT, prgn: &mut [u16], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut u16, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt16Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt16ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut u16, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut u16, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt16ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToUInt16ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut u16, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut u16, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt16ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt16WithDefault(varin: *const VARIANT, uidefault: u16) -> u16 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16WithDefault(varin : *const VARIANT, uidefault : u16) -> u16); - VariantToUInt16WithDefault(varin, uidefault) +pub unsafe fn VariantToUInt16WithDefault(varin: *const ::windows_core::VARIANT, uidefault: u16) -> u16 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt16WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, uidefault : u16) -> u16); + VariantToUInt16WithDefault(::core::mem::transmute(varin), uidefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt32(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32(varin : *const VARIANT, pulret : *mut u32) -> ::windows_core::HRESULT); +pub unsafe fn VariantToUInt32(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pulret : *mut u32) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToUInt32(varin, &mut result__).from_abi(result__) + VariantToUInt32(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt32Array(var: *const VARIANT, prgn: &mut [u32], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32Array(var : *const VARIANT, prgn : *mut u32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt32Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToUInt32Array(var: *const ::windows_core::VARIANT, prgn: &mut [u32], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut u32, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt32Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt32ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut u32, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt32ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToUInt32ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut u32, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt32ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt32WithDefault(varin: *const VARIANT, uldefault: u32) -> u32 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32WithDefault(varin : *const VARIANT, uldefault : u32) -> u32); - VariantToUInt32WithDefault(varin, uldefault) +pub unsafe fn VariantToUInt32WithDefault(varin: *const ::windows_core::VARIANT, uldefault: u32) -> u32 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt32WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, uldefault : u32) -> u32); + VariantToUInt32WithDefault(::core::mem::transmute(varin), uldefault) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt64(varin: *const VARIANT) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64(varin : *const VARIANT, pullret : *mut u64) -> ::windows_core::HRESULT); +pub unsafe fn VariantToUInt64(varin: *const ::windows_core::VARIANT) -> ::windows_core::Result { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pullret : *mut u64) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - VariantToUInt64(varin, &mut result__).from_abi(result__) + VariantToUInt64(::core::mem::transmute(varin), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt64Array(var: *const VARIANT, prgn: &mut [u64], pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64Array(var : *const VARIANT, prgn : *mut u64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt64Array(var, ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() +pub unsafe fn VariantToUInt64Array(var: *const ::windows_core::VARIANT, prgn: &mut [u64], pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64Array(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, prgn : *mut u64, crgn : u32, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt64Array(::core::mem::transmute(var), ::core::mem::transmute(prgn.as_ptr()), prgn.len().try_into().unwrap(), pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt64ArrayAlloc(var: *const VARIANT, pprgn: *mut *mut u64, pcelem: *mut u32) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64ArrayAlloc(var : *const VARIANT, pprgn : *mut *mut u64, pcelem : *mut u32) -> ::windows_core::HRESULT); - VariantToUInt64ArrayAlloc(var, pprgn, pcelem).ok() +pub unsafe fn VariantToUInt64ArrayAlloc(var: *const ::windows_core::VARIANT, pprgn: *mut *mut u64, pcelem: *mut u32) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64ArrayAlloc(var : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pprgn : *mut *mut u64, pcelem : *mut u32) -> ::windows_core::HRESULT); + VariantToUInt64ArrayAlloc(::core::mem::transmute(var), pprgn, pcelem).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] #[inline] -pub unsafe fn VariantToUInt64WithDefault(varin: *const VARIANT, ulldefault: u64) -> u64 { - ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64WithDefault(varin : *const VARIANT, ulldefault : u64) -> u64); - VariantToUInt64WithDefault(varin, ulldefault) +pub unsafe fn VariantToUInt64WithDefault(varin: *const ::windows_core::VARIANT, ulldefault: u64) -> u64 { + ::windows_targets::link!("propsys.dll" "system" fn VariantToUInt64WithDefault(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, ulldefault : u64) -> u64); + VariantToUInt64WithDefault(::core::mem::transmute(varin), ulldefault) } pub const DPF_ERROR: DRAWPROGRESSFLAGS = DRAWPROGRESSFLAGS(4i32); pub const DPF_MARQUEE: DRAWPROGRESSFLAGS = DRAWPROGRESSFLAGS(1i32); @@ -849,178 +685,3 @@ impl ::core::ops::Not for VAR_CHANGE_FLAGS { Self(self.0.not()) } } -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -pub struct VARIANT { - pub Anonymous: VARIANT_0, -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::clone::Clone for VARIANT { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::windows_core::TypeKind for VARIANT { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::default::Default for VARIANT { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -pub union VARIANT_0 { - pub Anonymous: ::std::mem::ManuallyDrop, - pub decVal: super::super::Foundation::DECIMAL, -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::clone::Clone for VARIANT_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::windows_core::TypeKind for VARIANT_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::default::Default for VARIANT_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -pub struct VARIANT_0_0 { - pub vt: VARENUM, - pub wReserved1: u16, - pub wReserved2: u16, - pub wReserved3: u16, - pub Anonymous: VARIANT_0_0_0, -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::clone::Clone for VARIANT_0_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::windows_core::TypeKind for VARIANT_0_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::default::Default for VARIANT_0_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -pub union VARIANT_0_0_0 { - pub llVal: i64, - pub lVal: i32, - pub bVal: u8, - pub iVal: i16, - pub fltVal: f32, - pub dblVal: f64, - pub boolVal: super::super::Foundation::VARIANT_BOOL, - pub __OBSOLETE__VARIANT_BOOL: super::super::Foundation::VARIANT_BOOL, - pub scode: i32, - pub cyVal: super::Com::CY, - pub date: f64, - pub bstrVal: ::std::mem::ManuallyDrop<::windows_core::BSTR>, - pub punkVal: ::std::mem::ManuallyDrop<::core::option::Option<::windows_core::IUnknown>>, - pub pdispVal: ::std::mem::ManuallyDrop<::core::option::Option>, - pub parray: *mut super::Com::SAFEARRAY, - pub pbVal: *mut u8, - pub piVal: *mut i16, - pub plVal: *mut i32, - pub pllVal: *mut i64, - pub pfltVal: *mut f32, - pub pdblVal: *mut f64, - pub pboolVal: *mut super::super::Foundation::VARIANT_BOOL, - pub __OBSOLETE__VARIANT_PBOOL: *mut super::super::Foundation::VARIANT_BOOL, - pub pscode: *mut i32, - pub pcyVal: *mut super::Com::CY, - pub pdate: *mut f64, - pub pbstrVal: *mut ::windows_core::BSTR, - pub ppunkVal: *mut ::core::option::Option<::windows_core::IUnknown>, - pub ppdispVal: *mut ::core::option::Option, - pub pparray: *mut *mut super::Com::SAFEARRAY, - pub pvarVal: *mut VARIANT, - pub byref: *mut ::core::ffi::c_void, - pub cVal: i8, - pub uiVal: u16, - pub ulVal: u32, - pub ullVal: u64, - pub intVal: i32, - pub uintVal: u32, - pub pdecVal: *mut super::super::Foundation::DECIMAL, - pub pcVal: ::windows_core::PSTR, - pub puiVal: *mut u16, - pub pulVal: *mut u32, - pub pullVal: *mut u64, - pub pintVal: *mut i32, - pub puintVal: *mut u32, - pub Anonymous: ::std::mem::ManuallyDrop, -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::clone::Clone for VARIANT_0_0_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::windows_core::TypeKind for VARIANT_0_0_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::default::Default for VARIANT_0_0_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} -#[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -pub struct VARIANT_0_0_0_0 { - pub pvRecord: *mut ::core::ffi::c_void, - pub pRecInfo: ::std::mem::ManuallyDrop<::core::option::Option>, -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::clone::Clone for VARIANT_0_0_0_0 { - fn clone(&self) -> Self { - unsafe { ::core::mem::transmute_copy(self) } - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::fmt::Debug for VARIANT_0_0_0_0 { - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_struct("VARIANT_0_0_0_0").field("pvRecord", &self.pvRecord).field("pRecInfo", &self.pRecInfo).finish() - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::windows_core::TypeKind for VARIANT_0_0_0_0 { - type TypeKind = ::windows_core::CopyType; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::cmp::PartialEq for VARIANT_0_0_0_0 { - fn eq(&self, other: &Self) -> bool { - self.pvRecord == other.pvRecord && self.pRecInfo == other.pRecInfo - } -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::cmp::Eq for VARIANT_0_0_0_0 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] -impl ::core::default::Default for VARIANT_0_0_0_0 { - fn default() -> Self { - unsafe { ::core::mem::zeroed() } - } -} diff --git a/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/impl.rs b/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/impl.rs index 34cde5e742..11af9c3f0a 100644 --- a/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/impl.rs @@ -402,27 +402,27 @@ impl IMetaDataDispenser_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IMetaDataDispenserEx_Impl: Sized + IMetaDataDispenser_Impl { - fn SetOption(&self, optionid: *const ::windows_core::GUID, value: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetOption(&self, optionid: *const ::windows_core::GUID, pvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetOption(&self, optionid: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetOption(&self, optionid: *const ::windows_core::GUID, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn OpenScopeOnITypeInfo(&self, piti: ::core::option::Option<&super::super::Com::ITypeInfo>, dwopenflags: u32, riid: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetCORSystemDirectory(&self, szbuffer: ::windows_core::PWSTR, cchbuffer: u32, pchbuffer: *mut u32) -> ::windows_core::Result<()>; fn FindAssembly(&self, szappbase: &::windows_core::PCWSTR, szprivatebin: &::windows_core::PCWSTR, szglobalbin: &::windows_core::PCWSTR, szassemblyname: &::windows_core::PCWSTR, szname: &::windows_core::PCWSTR, cchname: u32, pcname: *mut u32) -> ::windows_core::Result<()>; fn FindAssemblyModule(&self, szappbase: &::windows_core::PCWSTR, szprivatebin: &::windows_core::PCWSTR, szglobalbin: &::windows_core::PCWSTR, szassemblyname: &::windows_core::PCWSTR, szmodulename: &::windows_core::PCWSTR, szname: ::windows_core::PWSTR, cchname: u32, pcname: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IMetaDataDispenserEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IMetaDataDispenserEx_Vtbl { pub const fn new, Impl: IMetaDataDispenserEx_Impl, const OFFSET: isize>() -> IMetaDataDispenserEx_Vtbl { - unsafe extern "system" fn SetOption, Impl: IMetaDataDispenserEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, value: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetOption, Impl: IMetaDataDispenserEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetOption(::core::mem::transmute_copy(&optionid), ::core::mem::transmute_copy(&value)).into() } - unsafe extern "system" fn GetOption, Impl: IMetaDataDispenserEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, pvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetOption, Impl: IMetaDataDispenserEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetOption(::core::mem::transmute_copy(&optionid), ::core::mem::transmute_copy(&pvalue)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/mod.rs b/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/mod.rs index ee7da53cd0..490d63f0d9 100644 --- a/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/WinRT/Metadata/mod.rs @@ -382,15 +382,11 @@ impl IMetaDataDispenserEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.OpenScopeOnMemory)(::windows_core::Interface::as_raw(self), pdata, cbdata, dwopenflags, riid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetOption(&self, optionid: *const ::windows_core::GUID, value: *const super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), optionid, value).ok() + pub unsafe fn SetOption(&self, optionid: *const ::windows_core::GUID, value: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetOption)(::windows_core::Interface::as_raw(self), optionid, ::core::mem::transmute(value)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetOption(&self, optionid: *const ::windows_core::GUID, pvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetOption)(::windows_core::Interface::as_raw(self), optionid, pvalue).ok() + pub unsafe fn GetOption(&self, optionid: *const ::windows_core::GUID, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetOption)(::windows_core::Interface::as_raw(self), optionid, ::core::mem::transmute(pvalue)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -429,14 +425,8 @@ impl IMetaDataDispenserEx { #[doc(hidden)] pub struct IMetaDataDispenserEx_Vtbl { pub base__: IMetaDataDispenser_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, value: *const super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetOption: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, pvalue: *mut super::super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetOption: usize, + pub SetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, value: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetOption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, optionid: *const ::windows_core::GUID, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub OpenScopeOnITypeInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, piti: *mut ::core::ffi::c_void, dwopenflags: u32, riid: *const ::windows_core::GUID, ppiunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] diff --git a/crates/libs/windows/src/Windows/Win32/System/WindowsSync/impl.rs b/crates/libs/windows/src/Windows/Win32/System/WindowsSync/impl.rs index 9c1689929c..cc38c71f1d 100644 --- a/crates/libs/windows/src/Windows/Win32/System/WindowsSync/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/WindowsSync/impl.rs @@ -3169,14 +3169,14 @@ impl ISyncProviderConfigUI_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ISyncProviderConfigUIInfo_Impl: Sized + super::super::UI::Shell::PropertiesSystem::IPropertyStore_Impl { fn GetSyncProviderConfigUI(&self, dwclscontext: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ISyncProviderConfigUIInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ISyncProviderConfigUIInfo_Vtbl { pub const fn new, Impl: ISyncProviderConfigUIInfo_Impl, const OFFSET: isize>() -> ISyncProviderConfigUIInfo_Vtbl { unsafe extern "system" fn GetSyncProviderConfigUI, Impl: ISyncProviderConfigUIInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwclscontext: u32, ppsyncproviderconfigui: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3199,14 +3199,14 @@ impl ISyncProviderConfigUIInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ISyncProviderInfo_Impl: Sized + super::super::UI::Shell::PropertiesSystem::IPropertyStore_Impl { fn GetSyncProvider(&self, dwclscontext: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ISyncProviderInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ISyncProviderInfo_Vtbl { pub const fn new, Impl: ISyncProviderInfo_Impl, const OFFSET: isize>() -> ISyncProviderInfo_Vtbl { unsafe extern "system" fn GetSyncProvider, Impl: ISyncProviderInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwclscontext: u32, ppsyncprovider: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/System/WindowsSync/mod.rs b/crates/libs/windows/src/Windows/Win32/System/WindowsSync/mod.rs index 6832ca62d8..ed4c3e44a0 100644 --- a/crates/libs/windows/src/Windows/Win32/System/WindowsSync/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/WindowsSync/mod.rs @@ -2622,16 +2622,16 @@ impl ISyncProviderConfigUIInfo { pub unsafe fn GetAt(&self, iprop: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetAt)(::windows_core::Interface::as_raw(self), iprop, pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, propvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, propvar).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -2672,16 +2672,16 @@ impl ISyncProviderInfo { pub unsafe fn GetAt(&self, iprop: u32, pkey: *mut super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetAt)(::windows_core::Interface::as_raw(self), iprop, pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, propvar: *const super::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, propvar).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn SetValue(&self, key: *const super::super::UI::Shell::PropertiesSystem::PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] diff --git a/crates/libs/windows/src/Windows/Win32/System/Wmi/impl.rs b/crates/libs/windows/src/Windows/Win32/System/Wmi/impl.rs index fd9cc8dc6b..338cd78dfc 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Wmi/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Wmi/impl.rs @@ -86,8 +86,8 @@ impl IMofCompiler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemDateTime_Impl: Sized + super::Com::IDispatch_Impl { fn Value(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetValue(&self, strvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -130,9 +130,9 @@ pub trait ISWbemDateTime_Impl: Sized + super::Com::IDispatch_Impl { fn GetFileTime(&self, bislocal: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFileTime(&self, strfiletime: &::windows_core::BSTR, bislocal: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemDateTime {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemDateTime_Vtbl { pub const fn new, Impl: ISWbemDateTime_Impl, const OFFSET: isize>() -> ISWbemDateTime_Vtbl { unsafe extern "system" fn Value, Impl: ISWbemDateTime_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -503,15 +503,15 @@ impl ISWbemDateTime_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemEventSource_Impl: Sized + super::Com::IDispatch_Impl { fn NextEvent(&self, itimeoutms: i32) -> ::windows_core::Result; fn Security_(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemEventSource {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemEventSource_Vtbl { pub const fn new, Impl: ISWbemEventSource_Impl, const OFFSET: isize>() -> ISWbemEventSource_Vtbl { unsafe extern "system" fn NextEvent, Impl: ISWbemEventSource_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, itimeoutms: i32, objwbemobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -546,12 +546,12 @@ impl ISWbemEventSource_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemLastError_Impl: Sized + ISWbemObject_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemLastError {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemLastError_Vtbl { pub const fn new, Impl: ISWbemLastError_Impl, const OFFSET: isize>() -> ISWbemLastError_Vtbl { Self { base__: ISWbemObject_Vtbl::new::() } @@ -560,15 +560,15 @@ impl ISWbemLastError_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemLocator_Impl: Sized + super::Com::IDispatch_Impl { fn ConnectServer(&self, strserver: &::windows_core::BSTR, strnamespace: &::windows_core::BSTR, struser: &::windows_core::BSTR, strpassword: &::windows_core::BSTR, strlocale: &::windows_core::BSTR, strauthority: &::windows_core::BSTR, isecurityflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result; fn Security_(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemLocator {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemLocator_Vtbl { pub const fn new, Impl: ISWbemLocator_Impl, const OFFSET: isize>() -> ISWbemLocator_Vtbl { unsafe extern "system" fn ConnectServer, Impl: ISWbemLocator_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strserver: ::std::mem::MaybeUninit<::windows_core::BSTR>, strnamespace: ::std::mem::MaybeUninit<::windows_core::BSTR>, struser: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpassword: ::std::mem::MaybeUninit<::windows_core::BSTR>, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strauthority: ::std::mem::MaybeUninit<::windows_core::BSTR>, isecurityflags: i32, objwbemnamedvalueset: *mut ::core::ffi::c_void, objwbemservices: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -603,8 +603,8 @@ impl ISWbemLocator_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemMethod_Impl: Sized + super::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Origin(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -612,9 +612,9 @@ pub trait ISWbemMethod_Impl: Sized + super::Com::IDispatch_Impl { fn OutParameters(&self) -> ::windows_core::Result; fn Qualifiers_(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemMethod {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemMethod_Vtbl { pub const fn new, Impl: ISWbemMethod_Impl, const OFFSET: isize>() -> ISWbemMethod_Vtbl { unsafe extern "system" fn Name, Impl: ISWbemMethod_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -685,16 +685,16 @@ impl ISWbemMethod_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemMethodSet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemMethodSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemMethodSet_Vtbl { pub const fn new, Impl: ISWbemMethodSet_Impl, const OFFSET: isize>() -> ISWbemMethodSet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemMethodSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -741,19 +741,19 @@ impl ISWbemMethodSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemNamedValue_Impl: Sized + super::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemNamedValue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemNamedValue_Vtbl { pub const fn new, Impl: ISWbemNamedValue_Impl, const OFFSET: isize>() -> ISWbemNamedValue_Vtbl { - unsafe extern "system" fn Value, Impl: ISWbemNamedValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISWbemNamedValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -764,7 +764,7 @@ impl ISWbemNamedValue_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISWbemNamedValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISWbemNamedValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&varvalue)).into() @@ -791,20 +791,20 @@ impl ISWbemNamedValue_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemNamedValueSet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; - fn Add(&self, strname: &::windows_core::BSTR, varvalue: *const super::Variant::VARIANT, iflags: i32) -> ::windows_core::Result; + fn Add(&self, strname: &::windows_core::BSTR, varvalue: *const ::windows_core::VARIANT, iflags: i32) -> ::windows_core::Result; fn Remove(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; fn DeleteAll(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemNamedValueSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemNamedValueSet_Vtbl { pub const fn new, Impl: ISWbemNamedValueSet_Impl, const OFFSET: isize>() -> ISWbemNamedValueSet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemNamedValueSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -840,7 +840,7 @@ impl ISWbemNamedValueSet_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: ISWbemNamedValueSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *const super::Variant::VARIANT, iflags: i32, objwbemnamedvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: ISWbemNamedValueSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, iflags: i32, objwbemnamedvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::core::mem::transmute(&strname), ::core::mem::transmute_copy(&varvalue), ::core::mem::transmute_copy(&iflags)) { @@ -887,8 +887,8 @@ impl ISWbemNamedValueSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemObject_Impl: Sized + super::Com::IDispatch_Impl { fn Put_(&self, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result; fn PutAsync_(&self, objwbemsink: ::core::option::Option<&super::Com::IDispatch>, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>, objwbemasynccontext: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; @@ -912,13 +912,13 @@ pub trait ISWbemObject_Impl: Sized + super::Com::IDispatch_Impl { fn Qualifiers_(&self) -> ::windows_core::Result; fn Properties_(&self) -> ::windows_core::Result; fn Methods_(&self) -> ::windows_core::Result; - fn Derivation_(&self) -> ::windows_core::Result; + fn Derivation_(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Path_(&self) -> ::windows_core::Result; fn Security_(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemObject_Vtbl { pub const fn new, Impl: ISWbemObject_Impl, const OFFSET: isize>() -> ISWbemObject_Vtbl { unsafe extern "system" fn Put_, Impl: ISWbemObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iflags: i32, objwbemnamedvalueset: *mut ::core::ffi::c_void, objwbemobjectpath: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1156,7 +1156,7 @@ impl ISWbemObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Derivation_, Impl: ISWbemObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strclassnamearray: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Derivation_, Impl: ISWbemObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strclassnamearray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Derivation_() { @@ -1222,17 +1222,17 @@ impl ISWbemObject_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemObjectEx_Impl: Sized + ISWbemObject_Impl { fn Refresh_(&self, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn SystemProperties_(&self) -> ::windows_core::Result; fn GetText_(&self, iobjecttextformat: WbemObjectTextFormatEnum, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFromText_(&self, bstext: &::windows_core::BSTR, iobjecttextformat: WbemObjectTextFormatEnum, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemObjectEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemObjectEx_Vtbl { pub const fn new, Impl: ISWbemObjectEx_Impl, const OFFSET: isize>() -> ISWbemObjectEx_Vtbl { unsafe extern "system" fn Refresh_, Impl: ISWbemObjectEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iflags: i32, objwbemnamedvalueset: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1279,8 +1279,8 @@ impl ISWbemObjectEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemObjectPath_Impl: Sized + super::Com::IDispatch_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPath(&self, strpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -1306,9 +1306,9 @@ pub trait ISWbemObjectPath_Impl: Sized + super::Com::IDispatch_Impl { fn Authority(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetAuthority(&self, strauthority: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemObjectPath {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemObjectPath_Vtbl { pub const fn new, Impl: ISWbemObjectPath_Impl, const OFFSET: isize>() -> ISWbemObjectPath_Vtbl { unsafe extern "system" fn Path, Impl: ISWbemObjectPath_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strpath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1535,8 +1535,8 @@ impl ISWbemObjectPath_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemObjectSet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, strobjectpath: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result; @@ -1544,9 +1544,9 @@ pub trait ISWbemObjectSet_Impl: Sized + super::Com::IDispatch_Impl { fn Security_(&self) -> ::windows_core::Result; fn ItemIndex(&self, lindex: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemObjectSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemObjectSet_Vtbl { pub const fn new, Impl: ISWbemObjectSet_Impl, const OFFSET: isize>() -> ISWbemObjectSet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemObjectSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1617,8 +1617,8 @@ impl ISWbemObjectSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemPrivilege_Impl: Sized + super::Com::IDispatch_Impl { fn IsEnabled(&self) -> ::windows_core::Result; fn SetIsEnabled(&self, bisenabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -1626,9 +1626,9 @@ pub trait ISWbemPrivilege_Impl: Sized + super::Com::IDispatch_Impl { fn DisplayName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Identifier(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemPrivilege {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemPrivilege_Vtbl { pub const fn new, Impl: ISWbemPrivilege_Impl, const OFFSET: isize>() -> ISWbemPrivilege_Vtbl { unsafe extern "system" fn IsEnabled, Impl: ISWbemPrivilege_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bisenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1693,8 +1693,8 @@ impl ISWbemPrivilege_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemPrivilegeSet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, iprivilege: WbemPrivilegeEnum) -> ::windows_core::Result; @@ -1704,9 +1704,9 @@ pub trait ISWbemPrivilegeSet_Impl: Sized + super::Com::IDispatch_Impl { fn DeleteAll(&self) -> ::windows_core::Result<()>; fn AddAsString(&self, strprivilege: &::windows_core::BSTR, bisenabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemPrivilegeSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemPrivilegeSet_Vtbl { pub const fn new, Impl: ISWbemPrivilegeSet_Impl, const OFFSET: isize>() -> ISWbemPrivilegeSet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemPrivilegeSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1789,11 +1789,11 @@ impl ISWbemPrivilegeSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemProperty_Impl: Sized + super::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IsLocal(&self) -> ::windows_core::Result; fn Origin(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -1801,12 +1801,12 @@ pub trait ISWbemProperty_Impl: Sized + super::Com::IDispatch_Impl { fn Qualifiers_(&self) -> ::windows_core::Result; fn IsArray(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemProperty_Vtbl { pub const fn new, Impl: ISWbemProperty_Impl, const OFFSET: isize>() -> ISWbemProperty_Vtbl { - unsafe extern "system" fn Value, Impl: ISWbemProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISWbemProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -1817,7 +1817,7 @@ impl ISWbemProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISWbemProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISWbemProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&varvalue)).into() @@ -1904,8 +1904,8 @@ impl ISWbemProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemPropertySet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result; @@ -1913,9 +1913,9 @@ pub trait ISWbemPropertySet_Impl: Sized + super::Com::IDispatch_Impl { fn Add(&self, strname: &::windows_core::BSTR, icimtype: WbemCimtypeEnum, bisarray: super::super::Foundation::VARIANT_BOOL, iflags: i32) -> ::windows_core::Result; fn Remove(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemPropertySet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemPropertySet_Vtbl { pub const fn new, Impl: ISWbemPropertySet_Impl, const OFFSET: isize>() -> ISWbemPropertySet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemPropertySet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1980,11 +1980,11 @@ impl ISWbemPropertySet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemQualifier_Impl: Sized + super::Com::IDispatch_Impl { - fn Value(&self) -> ::windows_core::Result; - fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn IsLocal(&self) -> ::windows_core::Result; fn PropagatesToSubclass(&self) -> ::windows_core::Result; @@ -1995,12 +1995,12 @@ pub trait ISWbemQualifier_Impl: Sized + super::Com::IDispatch_Impl { fn SetIsOverridable(&self, bisoverridable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn IsAmended(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemQualifier {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemQualifier_Vtbl { pub const fn new, Impl: ISWbemQualifier_Impl, const OFFSET: isize>() -> ISWbemQualifier_Vtbl { - unsafe extern "system" fn Value, Impl: ISWbemQualifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: ISWbemQualifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -2011,7 +2011,7 @@ impl ISWbemQualifier_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: ISWbemQualifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ISWbemQualifier_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&varvalue)).into() @@ -2116,18 +2116,18 @@ impl ISWbemQualifier_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemQualifierSet_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, name: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result; fn Count(&self) -> ::windows_core::Result; - fn Add(&self, strname: &::windows_core::BSTR, varval: *const super::Variant::VARIANT, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32) -> ::windows_core::Result; + fn Add(&self, strname: &::windows_core::BSTR, varval: *const ::windows_core::VARIANT, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32) -> ::windows_core::Result; fn Remove(&self, strname: &::windows_core::BSTR, iflags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemQualifierSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemQualifierSet_Vtbl { pub const fn new, Impl: ISWbemQualifierSet_Impl, const OFFSET: isize>() -> ISWbemQualifierSet_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2163,7 +2163,7 @@ impl ISWbemQualifierSet_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: ISWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varval: *const super::Variant::VARIANT, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32, objwbemqualifier: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: ISWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32, objwbemqualifier: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::core::mem::transmute(&strname), ::core::mem::transmute_copy(&varval), ::core::mem::transmute_copy(&bpropagatestosubclass), ::core::mem::transmute_copy(&bpropagatestoinstance), ::core::mem::transmute_copy(&bisoverridable), ::core::mem::transmute_copy(&iflags)) { @@ -2192,8 +2192,8 @@ impl ISWbemQualifierSet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemRefreshableItem_Impl: Sized + super::Com::IDispatch_Impl { fn Index(&self) -> ::windows_core::Result; fn Refresher(&self) -> ::windows_core::Result; @@ -2202,9 +2202,9 @@ pub trait ISWbemRefreshableItem_Impl: Sized + super::Com::IDispatch_Impl { fn ObjectSet(&self) -> ::windows_core::Result; fn Remove(&self, iflags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemRefreshableItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemRefreshableItem_Vtbl { pub const fn new, Impl: ISWbemRefreshableItem_Impl, const OFFSET: isize>() -> ISWbemRefreshableItem_Vtbl { unsafe extern "system" fn Index, Impl: ISWbemRefreshableItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iindex: *mut i32) -> ::windows_core::HRESULT { @@ -2281,8 +2281,8 @@ impl ISWbemRefreshableItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemRefresher_Impl: Sized + super::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, iindex: i32) -> ::windows_core::Result; @@ -2295,9 +2295,9 @@ pub trait ISWbemRefresher_Impl: Sized + super::Com::IDispatch_Impl { fn SetAutoReconnect(&self, bcount: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn DeleteAll(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemRefresher {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemRefresher_Vtbl { pub const fn new, Impl: ISWbemRefresher_Impl, const OFFSET: isize>() -> ISWbemRefresher_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ISWbemRefresher_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2404,8 +2404,8 @@ impl ISWbemRefresher_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemSecurity_Impl: Sized + super::Com::IDispatch_Impl { fn ImpersonationLevel(&self) -> ::windows_core::Result; fn SetImpersonationLevel(&self, iimpersonationlevel: WbemImpersonationLevelEnum) -> ::windows_core::Result<()>; @@ -2413,9 +2413,9 @@ pub trait ISWbemSecurity_Impl: Sized + super::Com::IDispatch_Impl { fn SetAuthenticationLevel(&self, iauthenticationlevel: WbemAuthenticationLevelEnum) -> ::windows_core::Result<()>; fn Privileges(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemSecurity {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemSecurity_Vtbl { pub const fn new, Impl: ISWbemSecurity_Impl, const OFFSET: isize>() -> ISWbemSecurity_Vtbl { unsafe extern "system" fn ImpersonationLevel, Impl: ISWbemSecurity_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iimpersonationlevel: *mut WbemImpersonationLevelEnum) -> ::windows_core::HRESULT { @@ -2474,8 +2474,8 @@ impl ISWbemSecurity_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemServices_Impl: Sized + super::Com::IDispatch_Impl { fn Get(&self, strobjectpath: &::windows_core::BSTR, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result; fn GetAsync(&self, objwbemsink: ::core::option::Option<&super::Com::IDispatch>, strobjectpath: &::windows_core::BSTR, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>, objwbemasynccontext: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; @@ -2497,9 +2497,9 @@ pub trait ISWbemServices_Impl: Sized + super::Com::IDispatch_Impl { fn ExecMethodAsync(&self, objwbemsink: ::core::option::Option<&super::Com::IDispatch>, strobjectpath: &::windows_core::BSTR, strmethodname: &::windows_core::BSTR, objwbeminparameters: ::core::option::Option<&super::Com::IDispatch>, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>, objwbemasynccontext: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; fn Security_(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemServices_Vtbl { pub const fn new, Impl: ISWbemServices_Impl, const OFFSET: isize>() -> ISWbemServices_Vtbl { unsafe extern "system" fn Get, Impl: ISWbemServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strobjectpath: ::std::mem::MaybeUninit<::windows_core::BSTR>, iflags: i32, objwbemnamedvalueset: *mut ::core::ffi::c_void, objwbemobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2722,15 +2722,15 @@ impl ISWbemServices_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemServicesEx_Impl: Sized + ISWbemServices_Impl { fn Put(&self, objwbemobject: ::core::option::Option<&ISWbemObjectEx>, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result; fn PutAsync(&self, objwbemsink: ::core::option::Option<&ISWbemSink>, objwbemobject: ::core::option::Option<&ISWbemObjectEx>, iflags: i32, objwbemnamedvalueset: ::core::option::Option<&super::Com::IDispatch>, objwbemasynccontext: ::core::option::Option<&super::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemServicesEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemServicesEx_Vtbl { pub const fn new, Impl: ISWbemServicesEx_Impl, const OFFSET: isize>() -> ISWbemServicesEx_Vtbl { unsafe extern "system" fn Put, Impl: ISWbemServicesEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, objwbemobject: *mut ::core::ffi::c_void, iflags: i32, objwbemnamedvalueset: *mut ::core::ffi::c_void, objwbemobjectpath: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2755,14 +2755,14 @@ impl ISWbemServicesEx_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemSink_Impl: Sized + super::Com::IDispatch_Impl { fn Cancel(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemSink_Vtbl { pub const fn new, Impl: ISWbemSink_Impl, const OFFSET: isize>() -> ISWbemSink_Vtbl { unsafe extern "system" fn Cancel, Impl: ISWbemSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2776,12 +2776,12 @@ impl ISWbemSink_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISWbemSinkEvents_Impl: Sized + super::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISWbemSinkEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISWbemSinkEvents_Vtbl { pub const fn new, Impl: ISWbemSinkEvents_Impl, const OFFSET: isize>() -> ISWbemSinkEvents_Vtbl { Self { base__: super::Com::IDispatch_Vtbl::new::() } @@ -2813,16 +2813,16 @@ impl IUnsecuredApartment_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWMIExtension_Impl: Sized + super::Com::IDispatch_Impl { fn WMIObjectPath(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetWMIObject(&self) -> ::windows_core::Result; fn GetWMIServices(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWMIExtension {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWMIExtension_Vtbl { pub const fn new, Impl: IWMIExtension_Impl, const OFFSET: isize>() -> IWMIExtension_Vtbl { unsafe extern "system" fn WMIObjectPath, Impl: IWMIExtension_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strwmiobjectpath: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3005,16 +3005,16 @@ impl IWbemCallResult_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWbemClassObject_Impl: Sized { fn GetQualifierSet(&self) -> ::windows_core::Result; - fn Get(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()>; - fn Put(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *const super::Variant::VARIANT, r#type: i32) -> ::windows_core::Result<()>; + fn Get(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *mut ::windows_core::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()>; + fn Put(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *const ::windows_core::VARIANT, r#type: i32) -> ::windows_core::Result<()>; fn Delete(&self, wszname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; - fn GetNames(&self, wszqualifiername: &::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const super::Variant::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; + fn GetNames(&self, wszqualifiername: &::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const ::windows_core::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; fn BeginEnumeration(&self, lenumflags: i32) -> ::windows_core::Result<()>; - fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()>; + fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut ::windows_core::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()>; fn EndEnumeration(&self) -> ::windows_core::Result<()>; fn GetPropertyQualifierSet(&self, wszproperty: &::windows_core::PCWSTR) -> ::windows_core::Result; fn Clone(&self) -> ::windows_core::Result; @@ -3033,9 +3033,9 @@ pub trait IWbemClassObject_Impl: Sized { fn GetMethodQualifierSet(&self, wszmethod: &::windows_core::PCWSTR) -> ::windows_core::Result; fn GetMethodOrigin(&self, wszmethodname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWbemClassObject {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWbemClassObject_Vtbl { pub const fn new, Impl: IWbemClassObject_Impl, const OFFSET: isize>() -> IWbemClassObject_Vtbl { unsafe extern "system" fn GetQualifierSet, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppqualset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3049,12 +3049,12 @@ impl IWbemClassObject_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Get, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Get, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Get(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&ptype), ::core::mem::transmute_copy(&plflavor)).into() } - unsafe extern "system" fn Put, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *const super::Variant::VARIANT, r#type: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Put, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Put(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&r#type)).into() @@ -3064,7 +3064,7 @@ impl IWbemClassObject_Vtbl { let this = (*this).get_impl(); this.Delete(::core::mem::transmute(&wszname)).into() } - unsafe extern "system" fn GetNames, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszqualifiername: ::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const super::Variant::VARIANT, pnames: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetNames, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszqualifiername: ::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pnames: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetNames(::core::mem::transmute(&wszqualifiername), ::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pqualifierval)) { @@ -3080,7 +3080,7 @@ impl IWbemClassObject_Vtbl { let this = (*this).get_impl(); this.BeginEnumeration(::core::mem::transmute_copy(&lenumflags)).into() } - unsafe extern "system" fn Next, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IWbemClassObject_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&strname), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&ptype), ::core::mem::transmute_copy(&plflavor)).into() @@ -3427,22 +3427,22 @@ impl IWbemConstructClassObject_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWbemContext_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn GetNames(&self, lflags: i32) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; fn BeginEnumeration(&self, lflags: i32) -> ::windows_core::Result<()>; - fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn EndEnumeration(&self) -> ::windows_core::Result<()>; - fn SetValue(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetValue(&self, wszname: &::windows_core::PCWSTR, lflags: i32) -> ::windows_core::Result; + fn SetValue(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, wszname: &::windows_core::PCWSTR, lflags: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn DeleteValue(&self, wszname: &::windows_core::PCWSTR, lflags: i32) -> ::windows_core::Result<()>; fn DeleteAll(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWbemContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWbemContext_Vtbl { pub const fn new, Impl: IWbemContext_Impl, const OFFSET: isize>() -> IWbemContext_Vtbl { unsafe extern "system" fn Clone, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppnewcopy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3472,7 +3472,7 @@ impl IWbemContext_Vtbl { let this = (*this).get_impl(); this.BeginEnumeration(::core::mem::transmute_copy(&lflags)).into() } - unsafe extern "system" fn Next, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pstrname), ::core::mem::transmute_copy(&pvalue)).into() @@ -3482,12 +3482,12 @@ impl IWbemContext_Vtbl { let this = (*this).get_impl(); this.EndEnumeration().into() } - unsafe extern "system" fn SetValue, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pvalue)).into() } - unsafe extern "system" fn GetValue, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IWbemContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&lflags)) { @@ -3918,8 +3918,8 @@ impl IWbemLocator_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWbemObjectAccess_Impl: Sized + IWbemClassObject_Impl { fn GetPropertyHandle(&self, wszpropertyname: &::windows_core::PCWSTR, ptype: *mut i32, plhandle: *mut i32) -> ::windows_core::Result<()>; fn WritePropertyValue(&self, lhandle: i32, lnumbytes: i32, adata: *const u8) -> ::windows_core::Result<()>; @@ -3932,9 +3932,9 @@ pub trait IWbemObjectAccess_Impl: Sized + IWbemClassObject_Impl { fn Lock(&self, lflags: i32) -> ::windows_core::Result<()>; fn Unlock(&self, lflags: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWbemObjectAccess {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWbemObjectAccess_Vtbl { pub const fn new, Impl: IWbemObjectAccess_Impl, const OFFSET: isize>() -> IWbemObjectAccess_Vtbl { unsafe extern "system" fn GetPropertyHandle, Impl: IWbemObjectAccess_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszpropertyname: ::windows_core::PCWSTR, ptype: *mut i32, plhandle: *mut i32) -> ::windows_core::HRESULT { @@ -4044,18 +4044,14 @@ impl IWbemObjectSink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IWbemObjectSinkEx_Impl: Sized + IWbemObjectSink_Impl { fn WriteMessage(&self, uchannel: u32, strmessage: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn WriteError(&self, pobjerror: ::core::option::Option<&IWbemClassObject>) -> ::windows_core::Result; fn PromptUser(&self, strmessage: &::windows_core::BSTR, uprompttype: u8) -> ::windows_core::Result; fn WriteProgress(&self, stractivity: &::windows_core::BSTR, strcurrentoperation: &::windows_core::BSTR, strstatusdescription: &::windows_core::BSTR, upercentcomplete: u32, usecondsremaining: u32) -> ::windows_core::Result<()>; - fn WriteStreamParameter(&self, strname: &::windows_core::BSTR, vtvalue: *const super::Variant::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::Result<()>; + fn WriteStreamParameter(&self, strname: &::windows_core::BSTR, vtvalue: *const ::windows_core::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWbemObjectSinkEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IWbemObjectSinkEx_Vtbl { pub const fn new, Impl: IWbemObjectSinkEx_Impl, const OFFSET: isize>() -> IWbemObjectSinkEx_Vtbl { unsafe extern "system" fn WriteMessage, Impl: IWbemObjectSinkEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uchannel: u32, strmessage: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4090,7 +4086,7 @@ impl IWbemObjectSinkEx_Vtbl { let this = (*this).get_impl(); this.WriteProgress(::core::mem::transmute(&stractivity), ::core::mem::transmute(&strcurrentoperation), ::core::mem::transmute(&strstatusdescription), ::core::mem::transmute_copy(&upercentcomplete), ::core::mem::transmute_copy(&usecondsremaining)).into() } - unsafe extern "system" fn WriteStreamParameter, Impl: IWbemObjectSinkEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: *const super::Variant::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn WriteStreamParameter, Impl: IWbemObjectSinkEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ultype: u32, ulflags: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WriteStreamParameter(::core::mem::transmute(&strname), ::core::mem::transmute_copy(&vtvalue), ::core::mem::transmute_copy(&ultype), ::core::mem::transmute_copy(&ulflags)).into() @@ -4366,23 +4362,19 @@ impl IWbemPath_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IWbemPathKeyList_Impl: Sized { fn GetCount(&self) -> ::windows_core::Result; fn SetKey(&self, wszname: &::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn SetKey2(&self, wszname: &::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetKey2(&self, wszname: &::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn GetKey(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pukeyvalbufsize: *mut u32, pkeyval: *mut ::core::ffi::c_void, puapparentcimtype: *mut u32) -> ::windows_core::Result<()>; - fn GetKey2(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut super::Variant::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::Result<()>; + fn GetKey2(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut ::windows_core::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::Result<()>; fn RemoveKey(&self, wszname: &::windows_core::PCWSTR, uflags: u32) -> ::windows_core::Result<()>; fn RemoveAllKeys(&self, uflags: u32) -> ::windows_core::Result<()>; fn MakeSingleton(&self, bset: u8) -> ::windows_core::Result<()>; fn GetInfo(&self, urequestedinfo: u32) -> ::windows_core::Result; fn GetText(&self, lflags: i32, pubufflength: *mut u32, psztext: ::windows_core::PWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWbemPathKeyList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IWbemPathKeyList_Vtbl { pub const fn new, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>() -> IWbemPathKeyList_Vtbl { unsafe extern "system" fn GetCount, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pukeycount: *mut u32) -> ::windows_core::HRESULT { @@ -4401,7 +4393,7 @@ impl IWbemPathKeyList_Vtbl { let this = (*this).get_impl(); this.SetKey(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&uflags), ::core::mem::transmute_copy(&ucimtype), ::core::mem::transmute_copy(&pkeyval)).into() } - unsafe extern "system" fn SetKey2, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetKey2, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetKey2(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&uflags), ::core::mem::transmute_copy(&ucimtype), ::core::mem::transmute_copy(&pkeyval)).into() @@ -4411,7 +4403,7 @@ impl IWbemPathKeyList_Vtbl { let this = (*this).get_impl(); this.GetKey(::core::mem::transmute_copy(&ukeyix), ::core::mem::transmute_copy(&uflags), ::core::mem::transmute_copy(&punamebufsize), ::core::mem::transmute_copy(&pszkeyname), ::core::mem::transmute_copy(&pukeyvalbufsize), ::core::mem::transmute_copy(&pkeyval), ::core::mem::transmute_copy(&puapparentcimtype)).into() } - unsafe extern "system" fn GetKey2, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut super::Variant::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetKey2, Impl: IWbemPathKeyList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puapparentcimtype: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetKey2(::core::mem::transmute_copy(&ukeyix), ::core::mem::transmute_copy(&uflags), ::core::mem::transmute_copy(&punamebufsize), ::core::mem::transmute_copy(&pszkeyname), ::core::mem::transmute_copy(&pkeyvalue), ::core::mem::transmute_copy(&puapparentcimtype)).into() @@ -4465,18 +4457,14 @@ impl IWbemPathKeyList_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IWbemPropertyProvider_Impl: Sized { - fn GetProperty(&self, lflags: i32, strlocale: &::windows_core::BSTR, strclassmapping: &::windows_core::BSTR, strinstmapping: &::windows_core::BSTR, strpropmapping: &::windows_core::BSTR) -> ::windows_core::Result; - fn PutProperty(&self, lflags: i32, strlocale: &::windows_core::BSTR, strclassmapping: &::windows_core::BSTR, strinstmapping: &::windows_core::BSTR, strpropmapping: &::windows_core::BSTR, pvvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, lflags: i32, strlocale: &::windows_core::BSTR, strclassmapping: &::windows_core::BSTR, strinstmapping: &::windows_core::BSTR, strpropmapping: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PutProperty(&self, lflags: i32, strlocale: &::windows_core::BSTR, strclassmapping: &::windows_core::BSTR, strinstmapping: &::windows_core::BSTR, strpropmapping: &::windows_core::BSTR, pvvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IWbemPropertyProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IWbemPropertyProvider_Vtbl { pub const fn new, Impl: IWbemPropertyProvider_Impl, const OFFSET: isize>() -> IWbemPropertyProvider_Vtbl { - unsafe extern "system" fn GetProperty, Impl: IWbemPropertyProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IWbemPropertyProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&strlocale), ::core::mem::transmute(&strclassmapping), ::core::mem::transmute(&strinstmapping), ::core::mem::transmute(&strpropmapping)) { @@ -4487,7 +4475,7 @@ impl IWbemPropertyProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PutProperty, Impl: IWbemPropertyProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutProperty, Impl: IWbemPropertyProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutProperty(::core::mem::transmute_copy(&lflags), ::core::mem::transmute(&strlocale), ::core::mem::transmute(&strclassmapping), ::core::mem::transmute(&strinstmapping), ::core::mem::transmute(&strpropmapping), ::core::mem::transmute_copy(&pvvalue)).into() @@ -4553,28 +4541,28 @@ impl IWbemProviderInitSink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWbemQualifierSet_Impl: Sized { - fn Get(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()>; - fn Put(&self, wszname: &::windows_core::PCWSTR, pval: *const super::Variant::VARIANT, lflavor: i32) -> ::windows_core::Result<()>; + fn Get(&self, wszname: &::windows_core::PCWSTR, lflags: i32, pval: *mut ::windows_core::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()>; + fn Put(&self, wszname: &::windows_core::PCWSTR, pval: *const ::windows_core::VARIANT, lflavor: i32) -> ::windows_core::Result<()>; fn Delete(&self, wszname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetNames(&self, lflags: i32) -> ::windows_core::Result<*mut super::Com::SAFEARRAY>; fn BeginEnumeration(&self, lflags: i32) -> ::windows_core::Result<()>; - fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()>; + fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pval: *mut ::windows_core::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()>; fn EndEnumeration(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWbemQualifierSet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWbemQualifierSet_Vtbl { pub const fn new, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>() -> IWbemQualifierSet_Vtbl { - unsafe extern "system" fn Get, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Get, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plflavor: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Get(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&plflavor)).into() } - unsafe extern "system" fn Put, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, pval: *const super::Variant::VARIANT, lflavor: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Put, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, pval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lflavor: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Put(::core::mem::transmute(&wszname), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&lflavor)).into() @@ -4600,7 +4588,7 @@ impl IWbemQualifierSet_Vtbl { let this = (*this).get_impl(); this.BeginEnumeration(::core::mem::transmute_copy(&lflags)).into() } - unsafe extern "system" fn Next, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Next, Impl: IWbemQualifierSet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plflavor: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Next(::core::mem::transmute_copy(&lflags), ::core::mem::transmute_copy(&pstrname), ::core::mem::transmute_copy(&pval), ::core::mem::transmute_copy(&plflavor)).into() diff --git a/crates/libs/windows/src/Windows/Win32/System/Wmi/mod.rs b/crates/libs/windows/src/Windows/Win32/System/Wmi/mod.rs index 2b44416b45..977b9999e9 100644 --- a/crates/libs/windows/src/Windows/Win32/System/Wmi/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/System/Wmi/mod.rs @@ -576,9 +576,7 @@ impl ISWbemLastError { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Methods_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Derivation_(&self) -> ::windows_core::Result { + pub unsafe fn Derivation_(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Derivation_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -758,16 +756,12 @@ pub struct ISWbemMethodSet_Vtbl { ::windows_core::imp::interface_hierarchy!(ISWbemNamedValue, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISWbemNamedValue { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), varvalue).ok() + pub unsafe fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() } pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -779,14 +773,8 @@ impl ISWbemNamedValue { #[doc(hidden)] pub struct ISWbemNamedValue_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -817,14 +805,14 @@ impl ISWbemNamedValueSet { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, strname: P0, varvalue: *const super::Variant::VARIANT, iflags: i32) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, strname: P0, varvalue: *const ::windows_core::VARIANT, iflags: i32) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), varvalue, iflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), ::core::mem::transmute(varvalue), iflags, &mut result__).from_abi(result__) } pub unsafe fn Remove(&self, strname: P0, iflags: i32) -> ::windows_core::Result<()> where @@ -853,9 +841,9 @@ pub struct ISWbemNamedValueSet_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, icount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *const super::Variant::VARIANT, iflags: i32, objwbemnamedvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, iflags: i32, objwbemnamedvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, iflags: i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -1086,9 +1074,7 @@ impl ISWbemObject { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Methods_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Derivation_(&self) -> ::windows_core::Result { + pub unsafe fn Derivation_(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Derivation_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1195,10 +1181,7 @@ pub struct ISWbemObject_Vtbl { pub Methods_: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objwbemmethodset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Methods_: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Derivation_: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strclassnamearray: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Derivation_: usize, + pub Derivation_: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strclassnamearray: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Path_: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, objwbemobjectpath: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -1430,9 +1413,7 @@ impl ISWbemObjectEx { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Methods_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Derivation_(&self) -> ::windows_core::Result { + pub unsafe fn Derivation_(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Derivation_)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1850,16 +1831,12 @@ pub struct ISWbemPrivilegeSet_Vtbl { ::windows_core::imp::interface_hierarchy!(ISWbemProperty, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISWbemProperty { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), varvalue).ok() + pub unsafe fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() } pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -1893,14 +1870,8 @@ impl ISWbemProperty { #[doc(hidden)] pub struct ISWbemProperty_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsLocal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bislocal: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub Origin: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strorigin: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1984,16 +1955,12 @@ pub struct ISWbemPropertySet_Vtbl { ::windows_core::imp::interface_hierarchy!(ISWbemQualifier, ::windows_core::IUnknown, super::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl ISWbemQualifier { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, varvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), varvalue).ok() + pub unsafe fn SetValue(&self, varvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varvalue)).ok() } pub unsafe fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2043,14 +2010,8 @@ impl ISWbemQualifier { #[doc(hidden)] pub struct ISWbemQualifier_Vtbl { pub base__: super::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsLocal: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bislocal: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub PropagatesToSubclass: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bpropagatestosubclass: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -2089,9 +2050,9 @@ impl ISWbemQualifierSet { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, strname: P0, varval: *const super::Variant::VARIANT, bpropagatestosubclass: P1, bpropagatestoinstance: P2, bisoverridable: P3, iflags: i32) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, strname: P0, varval: *const ::windows_core::VARIANT, bpropagatestosubclass: P1, bpropagatestoinstance: P2, bisoverridable: P3, iflags: i32) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam, @@ -2099,7 +2060,7 @@ impl ISWbemQualifierSet { P3: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), varval, bpropagatestosubclass.into_param().abi(), bpropagatestoinstance.into_param().abi(), bisoverridable.into_param().abi(), iflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), ::core::mem::transmute(varval), bpropagatestosubclass.into_param().abi(), bpropagatestoinstance.into_param().abi(), bisoverridable.into_param().abi(), iflags, &mut result__).from_abi(result__) } pub unsafe fn Remove(&self, strname: P0, iflags: i32) -> ::windows_core::Result<()> where @@ -2119,9 +2080,9 @@ pub struct ISWbemQualifierSet_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, icount: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varval: *const super::Variant::VARIANT, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32, objwbemqualifier: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, varval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, bpropagatestosubclass: super::super::Foundation::VARIANT_BOOL, bpropagatestoinstance: super::super::Foundation::VARIANT_BOOL, bisoverridable: super::super::Foundation::VARIANT_BOOL, iflags: i32, objwbemqualifier: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, iflags: i32) -> ::windows_core::HRESULT, } @@ -3126,21 +3087,17 @@ impl IWbemClassObject { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetQualifierSet)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut super::Variant::VARIANT, ptype: ::core::option::Option<*mut i32>, plflavor: ::core::option::Option<*mut i32>) -> ::windows_core::Result<()> + pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut ::windows_core::VARIANT, ptype: ::core::option::Option<*mut i32>, plflavor: ::core::option::Option<*mut i32>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pval, ::core::mem::transmute(ptype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plflavor.unwrap_or(::std::ptr::null_mut()))).ok() + (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pval), ::core::mem::transmute(ptype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plflavor.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, wszname: P0, lflags: i32, pval: *const super::Variant::VARIANT, r#type: i32) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, wszname: P0, lflags: i32, pval: *const ::windows_core::VARIANT, r#type: i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pval, r#type).ok() + (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pval), r#type).ok() } pub unsafe fn Delete(&self, wszname: P0) -> ::windows_core::Result<()> where @@ -3148,22 +3105,20 @@ impl IWbemClassObject { { (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), wszname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetNames(&self, wszqualifiername: P0, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const super::Variant::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetNames(&self, wszqualifiername: P0, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const ::windows_core::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetNames)(::windows_core::Interface::as_raw(self), wszqualifiername.into_param().abi(), lflags, pqualifierval, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetNames)(::windows_core::Interface::as_raw(self), wszqualifiername.into_param().abi(), lflags, ::core::mem::transmute(pqualifierval), &mut result__).from_abi(result__) } pub unsafe fn BeginEnumeration(&self, lenumflags: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BeginEnumeration)(::windows_core::Interface::as_raw(self), lenumflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(strname), pval, ptype, plflavor).ok() + pub unsafe fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut ::windows_core::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(strname), ::core::mem::transmute(pval), ptype, plflavor).ok() } pub unsafe fn EndEnumeration(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndEnumeration)(::windows_core::Interface::as_raw(self)).ok() @@ -3259,24 +3214,15 @@ impl IWbemClassObject { pub struct IWbemClassObject_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetQualifierSet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppqualset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Get: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *const super::Variant::VARIANT, r#type: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Put: usize, + pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT, + pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, r#type: i32) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszqualifiername: ::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const super::Variant::VARIANT, pnames: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GetNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszqualifiername: ::windows_core::PCWSTR, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pnames: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetNames: usize, pub BeginEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lenumflags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::HRESULT, pub EndEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetPropertyQualifierSet: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszproperty: ::windows_core::PCWSTR, ppqualset: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcopy: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3479,25 +3425,19 @@ impl IWbemContext { pub unsafe fn BeginEnumeration(&self, lflags: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BeginEnumeration)(::windows_core::Interface::as_raw(self), lflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(pstrname), pvalue).ok() + pub unsafe fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(pstrname), ::core::mem::transmute(pvalue)).ok() } pub unsafe fn EndEnumeration(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndEnumeration)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, wszname: P0, lflags: i32, pvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetValue(&self, wszname: P0, lflags: i32, pvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pvalue).ok() + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, wszname: P0, lflags: i32) -> ::windows_core::Result + pub unsafe fn GetValue(&self, wszname: P0, lflags: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { @@ -3524,19 +3464,10 @@ pub struct IWbemContext_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] GetNames: usize, pub BeginEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub EndEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub DeleteValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32) -> ::windows_core::HRESULT, pub DeleteAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -3869,21 +3800,17 @@ impl IWbemObjectAccess { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetQualifierSet)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut super::Variant::VARIANT, ptype: ::core::option::Option<*mut i32>, plflavor: ::core::option::Option<*mut i32>) -> ::windows_core::Result<()> + pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut ::windows_core::VARIANT, ptype: ::core::option::Option<*mut i32>, plflavor: ::core::option::Option<*mut i32>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pval, ::core::mem::transmute(ptype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plflavor.unwrap_or(::std::ptr::null_mut()))).ok() + (::windows_core::Interface::vtable(self).base__.Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pval), ::core::mem::transmute(ptype.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(plflavor.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, wszname: P0, lflags: i32, pval: *const super::Variant::VARIANT, r#type: i32) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, wszname: P0, lflags: i32, pval: *const ::windows_core::VARIANT, r#type: i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pval, r#type).ok() + (::windows_core::Interface::vtable(self).base__.Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pval), r#type).ok() } pub unsafe fn Delete(&self, wszname: P0) -> ::windows_core::Result<()> where @@ -3891,22 +3818,20 @@ impl IWbemObjectAccess { { (::windows_core::Interface::vtable(self).base__.Delete)(::windows_core::Interface::as_raw(self), wszname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetNames(&self, wszqualifiername: P0, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const super::Variant::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetNames(&self, wszqualifiername: P0, lflags: WBEM_CONDITION_FLAG_TYPE, pqualifierval: *const ::windows_core::VARIANT) -> ::windows_core::Result<*mut super::Com::SAFEARRAY> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetNames)(::windows_core::Interface::as_raw(self), wszqualifiername.into_param().abi(), lflags, pqualifierval, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetNames)(::windows_core::Interface::as_raw(self), wszqualifiername.into_param().abi(), lflags, ::core::mem::transmute(pqualifierval), &mut result__).from_abi(result__) } pub unsafe fn BeginEnumeration(&self, lenumflags: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.BeginEnumeration)(::windows_core::Interface::as_raw(self), lenumflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut super::Variant::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(strname), pval, ptype, plflavor).ok() + pub unsafe fn Next(&self, lflags: i32, strname: *mut ::windows_core::BSTR, pval: *mut ::windows_core::VARIANT, ptype: *mut i32, plflavor: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(strname), ::core::mem::transmute(pval), ptype, plflavor).ok() } pub unsafe fn EndEnumeration(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.EndEnumeration)(::windows_core::Interface::as_raw(self)).ok() @@ -4109,13 +4034,11 @@ impl IWbemObjectSinkEx { { (::windows_core::Interface::vtable(self).WriteProgress)(::windows_core::Interface::as_raw(self), stractivity.into_param().abi(), strcurrentoperation.into_param().abi(), strstatusdescription.into_param().abi(), upercentcomplete, usecondsremaining).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn WriteStreamParameter(&self, strname: P0, vtvalue: *const super::Variant::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::Result<()> + pub unsafe fn WriteStreamParameter(&self, strname: P0, vtvalue: *const ::windows_core::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).WriteStreamParameter)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), vtvalue, ultype, ulflags).ok() + (::windows_core::Interface::vtable(self).WriteStreamParameter)(::windows_core::Interface::as_raw(self), strname.into_param().abi(), ::core::mem::transmute(vtvalue), ultype, ulflags).ok() } } #[repr(C)] @@ -4126,10 +4049,7 @@ pub struct IWbemObjectSinkEx_Vtbl { pub WriteError: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pobjerror: *mut ::core::ffi::c_void, pureturned: *mut u8) -> ::windows_core::HRESULT, pub PromptUser: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strmessage: ::std::mem::MaybeUninit<::windows_core::BSTR>, uprompttype: u8, pureturned: *mut u8) -> ::windows_core::HRESULT, pub WriteProgress: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, stractivity: ::std::mem::MaybeUninit<::windows_core::BSTR>, strcurrentoperation: ::std::mem::MaybeUninit<::windows_core::BSTR>, strstatusdescription: ::std::mem::MaybeUninit<::windows_core::BSTR>, upercentcomplete: u32, usecondsremaining: u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub WriteStreamParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: *const super::Variant::VARIANT, ultype: u32, ulflags: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - WriteStreamParameter: usize, + pub WriteStreamParameter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, ultype: u32, ulflags: u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWbemObjectTextSrc, IWbemObjectTextSrc_Vtbl, 0xbfbf883a_cad7_11d3_a11b_00105a1f515a); ::windows_core::imp::interface_hierarchy!(IWbemObjectTextSrc, ::windows_core::IUnknown); @@ -4323,21 +4243,17 @@ impl IWbemPathKeyList { { (::windows_core::Interface::vtable(self).SetKey)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), uflags, ucimtype, pkeyval).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetKey2(&self, wszname: P0, uflags: u32, ucimtype: u32, pkeyval: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetKey2(&self, wszname: P0, uflags: u32, ucimtype: u32, pkeyval: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetKey2)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), uflags, ucimtype, pkeyval).ok() + (::windows_core::Interface::vtable(self).SetKey2)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), uflags, ucimtype, ::core::mem::transmute(pkeyval)).ok() } pub unsafe fn GetKey(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pukeyvalbufsize: *mut u32, pkeyval: *mut ::core::ffi::c_void, puapparentcimtype: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetKey)(::windows_core::Interface::as_raw(self), ukeyix, uflags, punamebufsize, ::core::mem::transmute(pszkeyname), pukeyvalbufsize, pkeyval, puapparentcimtype).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetKey2(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut super::Variant::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetKey2)(::windows_core::Interface::as_raw(self), ukeyix, uflags, punamebufsize, ::core::mem::transmute(pszkeyname), pkeyvalue, puapparentcimtype).ok() + pub unsafe fn GetKey2(&self, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut ::windows_core::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetKey2)(::windows_core::Interface::as_raw(self), ukeyix, uflags, punamebufsize, ::core::mem::transmute(pszkeyname), ::core::mem::transmute(pkeyvalue), puapparentcimtype).ok() } pub unsafe fn RemoveKey(&self, wszname: P0, uflags: u32) -> ::windows_core::Result<()> where @@ -4365,15 +4281,9 @@ pub struct IWbemPathKeyList_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pukeycount: *mut u32) -> ::windows_core::HRESULT, pub SetKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetKey2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetKey2: usize, + pub SetKey2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32, ucimtype: u32, pkeyval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pukeyvalbufsize: *mut u32, pkeyval: *mut ::core::ffi::c_void, puapparentcimtype: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetKey2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut super::Variant::VARIANT, puapparentcimtype: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetKey2: usize, + pub GetKey2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ukeyix: u32, uflags: u32, punamebufsize: *mut u32, pszkeyname: ::windows_core::PWSTR, pkeyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, puapparentcimtype: *mut u32) -> ::windows_core::HRESULT, pub RemoveKey: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, uflags: u32) -> ::windows_core::HRESULT, pub RemoveAllKeys: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uflags: u32) -> ::windows_core::HRESULT, pub MakeSingleton: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bset: u8) -> ::windows_core::HRESULT, @@ -4383,9 +4293,7 @@ pub struct IWbemPathKeyList_Vtbl { ::windows_core::imp::com_interface!(IWbemPropertyProvider, IWbemPropertyProvider_Vtbl, 0xce61e841_65bc_11d0_b6bd_00aa003240c7); ::windows_core::imp::interface_hierarchy!(IWbemPropertyProvider, ::windows_core::IUnknown); impl IWbemPropertyProvider { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, lflags: i32, strlocale: P0, strclassmapping: P1, strinstmapping: P2, strpropmapping: P3) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, lflags: i32, strlocale: P0, strclassmapping: P1, strinstmapping: P2, strpropmapping: P3) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -4395,30 +4303,22 @@ impl IWbemPropertyProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), lflags, strlocale.into_param().abi(), strclassmapping.into_param().abi(), strinstmapping.into_param().abi(), strpropmapping.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutProperty(&self, lflags: i32, strlocale: P0, strclassmapping: P1, strinstmapping: P2, strpropmapping: P3, pvvalue: *const super::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutProperty(&self, lflags: i32, strlocale: P0, strclassmapping: P1, strinstmapping: P2, strpropmapping: P3, pvvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, P3: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), lflags, strlocale.into_param().abi(), strclassmapping.into_param().abi(), strinstmapping.into_param().abi(), strpropmapping.into_param().abi(), pvvalue).ok() + (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), lflags, strlocale.into_param().abi(), strclassmapping.into_param().abi(), strinstmapping.into_param().abi(), strpropmapping.into_param().abi(), ::core::mem::transmute(pvvalue)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IWbemPropertyProvider_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *mut super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *const super::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutProperty: usize, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, strlocale: ::std::mem::MaybeUninit<::windows_core::BSTR>, strclassmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strinstmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, strpropmapping: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWbemProviderIdentity, IWbemProviderIdentity_Vtbl, 0x631f7d97_d993_11d2_b339_00105a1f4aaf); ::windows_core::imp::interface_hierarchy!(IWbemProviderIdentity, ::windows_core::IUnknown); @@ -4473,21 +4373,17 @@ pub struct IWbemProviderInitSink_Vtbl { ::windows_core::imp::com_interface!(IWbemQualifierSet, IWbemQualifierSet_Vtbl, 0xdc12a680_737f_11cf_884d_00aa004b2e24); ::windows_core::imp::interface_hierarchy!(IWbemQualifierSet, ::windows_core::IUnknown); impl IWbemQualifierSet { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()> + pub unsafe fn Get(&self, wszname: P0, lflags: i32, pval: *mut ::windows_core::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, pval, plflavor).ok() + (::windows_core::Interface::vtable(self).Get)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), lflags, ::core::mem::transmute(pval), plflavor).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Put(&self, wszname: P0, pval: *const super::Variant::VARIANT, lflavor: i32) -> ::windows_core::Result<()> + pub unsafe fn Put(&self, wszname: P0, pval: *const ::windows_core::VARIANT, lflavor: i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), pval, lflavor).ok() + (::windows_core::Interface::vtable(self).Put)(::windows_core::Interface::as_raw(self), wszname.into_param().abi(), ::core::mem::transmute(pval), lflavor).ok() } pub unsafe fn Delete(&self, wszname: P0) -> ::windows_core::Result<()> where @@ -4504,10 +4400,8 @@ impl IWbemQualifierSet { pub unsafe fn BeginEnumeration(&self, lflags: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BeginEnumeration)(::windows_core::Interface::as_raw(self), lflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(pstrname), pval, plflavor).ok() + pub unsafe fn Next(&self, lflags: i32, pstrname: *mut ::windows_core::BSTR, pval: *mut ::windows_core::VARIANT, plflavor: *mut i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), lflags, ::core::mem::transmute(pstrname), ::core::mem::transmute(pval), plflavor).ok() } pub unsafe fn EndEnumeration(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndEnumeration)(::windows_core::Interface::as_raw(self)).ok() @@ -4517,24 +4411,15 @@ impl IWbemQualifierSet { #[doc(hidden)] pub struct IWbemQualifierSet_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Get: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, pval: *const super::Variant::VARIANT, lflavor: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Put: usize, + pub Get: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, lflags: i32, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plflavor: *mut i32) -> ::windows_core::HRESULT, + pub Put: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR, pval: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, lflavor: i32) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, wszname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetNames: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pnames: *mut *mut super::Com::SAFEARRAY) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetNames: usize, pub BeginEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut super::Variant::VARIANT, plflavor: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, + pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lflags: i32, pstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, pval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, plflavor: *mut i32) -> ::windows_core::HRESULT, pub EndEnumeration: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IWbemQuery, IWbemQuery_Vtbl, 0x81166f58_dd98_11d3_a120_00105a1f515a); diff --git a/crates/libs/windows/src/Windows/Win32/UI/Accessibility/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/Accessibility/impl.rs index 8999d199ff..1a15f817c9 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Accessibility/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Accessibility/impl.rs @@ -15,17 +15,13 @@ impl IAccIdentity_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IAccPropServer_Impl: Sized { - fn GetPropValue(&self, pidstring: *const u8, dwidstringlen: u32, idprop: &::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; + fn GetPropValue(&self, pidstring: *const u8, dwidstringlen: u32, idprop: &::windows_core::GUID, pvarvalue: *mut ::windows_core::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IAccPropServer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IAccPropServer_Vtbl { pub const fn new, Impl: IAccPropServer_Impl, const OFFSET: isize>() -> IAccPropServer_Vtbl { - unsafe extern "system" fn GetPropValue, Impl: IAccPropServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropValue, Impl: IAccPropServer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPropValue(::core::mem::transmute_copy(&pidstring), ::core::mem::transmute_copy(&dwidstringlen), ::core::mem::transmute(&idprop), ::core::mem::transmute_copy(&pvarvalue), ::core::mem::transmute_copy(&pfhasprop)).into() @@ -36,31 +32,31 @@ impl IAccPropServer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(feature = "Win32_UI_WindowsAndMessaging")] pub trait IAccPropServices_Impl: Sized { - fn SetPropValue(&self, pidstring: *const u8, dwidstringlen: u32, idprop: &::windows_core::GUID, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetPropValue(&self, pidstring: *const u8, dwidstringlen: u32, idprop: &::windows_core::GUID, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetPropServer(&self, pidstring: *const u8, dwidstringlen: u32, paprops: *const ::windows_core::GUID, cprops: i32, pserver: ::core::option::Option<&IAccPropServer>, annoscope: AnnoScope) -> ::windows_core::Result<()>; fn ClearProps(&self, pidstring: *const u8, dwidstringlen: u32, paprops: *const ::windows_core::GUID, cprops: i32) -> ::windows_core::Result<()>; - fn SetHwndProp(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: &::windows_core::GUID, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetHwndProp(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: &::windows_core::GUID, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetHwndPropStr(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: &::windows_core::GUID, str: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn SetHwndPropServer(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32, pserver: ::core::option::Option<&IAccPropServer>, annoscope: AnnoScope) -> ::windows_core::Result<()>; fn ClearHwndProps(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32) -> ::windows_core::Result<()>; fn ComposeHwndIdentityString(&self, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, ppidstring: *mut *mut u8, pdwidstringlen: *mut u32) -> ::windows_core::Result<()>; fn DecomposeHwndIdentityString(&self, pidstring: *const u8, dwidstringlen: u32, phwnd: *mut super::super::Foundation::HWND, pidobject: *mut u32, pidchild: *mut u32) -> ::windows_core::Result<()>; - fn SetHmenuProp(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: &::windows_core::GUID, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetHmenuProp(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: &::windows_core::GUID, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SetHmenuPropStr(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: &::windows_core::GUID, str: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn SetHmenuPropServer(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32, pserver: ::core::option::Option<&IAccPropServer>, annoscope: AnnoScope) -> ::windows_core::Result<()>; fn ClearHmenuProps(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32) -> ::windows_core::Result<()>; fn ComposeHmenuIdentityString(&self, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, ppidstring: *mut *mut u8, pdwidstringlen: *mut u32) -> ::windows_core::Result<()>; fn DecomposeHmenuIdentityString(&self, pidstring: *const u8, dwidstringlen: u32, phmenu: *mut super::WindowsAndMessaging::HMENU, pidchild: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(feature = "Win32_UI_WindowsAndMessaging")] impl ::windows_core::RuntimeName for IAccPropServices {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(feature = "Win32_UI_WindowsAndMessaging")] impl IAccPropServices_Vtbl { pub const fn new, Impl: IAccPropServices_Impl, const OFFSET: isize>() -> IAccPropServices_Vtbl { - unsafe extern "system" fn SetPropValue, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPropValue, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetPropValue(::core::mem::transmute_copy(&pidstring), ::core::mem::transmute_copy(&dwidstringlen), ::core::mem::transmute(&idprop), ::core::mem::transmute(&var)).into() @@ -75,7 +71,7 @@ impl IAccPropServices_Vtbl { let this = (*this).get_impl(); this.ClearProps(::core::mem::transmute_copy(&pidstring), ::core::mem::transmute_copy(&dwidstringlen), ::core::mem::transmute_copy(&paprops), ::core::mem::transmute_copy(&cprops)).into() } - unsafe extern "system" fn SetHwndProp, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetHwndProp, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetHwndProp(::core::mem::transmute_copy(&hwnd), ::core::mem::transmute_copy(&idobject), ::core::mem::transmute_copy(&idchild), ::core::mem::transmute(&idprop), ::core::mem::transmute(&var)).into() @@ -105,7 +101,7 @@ impl IAccPropServices_Vtbl { let this = (*this).get_impl(); this.DecomposeHwndIdentityString(::core::mem::transmute_copy(&pidstring), ::core::mem::transmute_copy(&dwidstringlen), ::core::mem::transmute_copy(&phwnd), ::core::mem::transmute_copy(&pidobject), ::core::mem::transmute_copy(&pidchild)).into() } - unsafe extern "system" fn SetHmenuProp, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetHmenuProp, Impl: IAccPropServices_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetHmenuProp(::core::mem::transmute_copy(&hmenu), ::core::mem::transmute_copy(&idchild), ::core::mem::transmute(&idprop), ::core::mem::transmute(&var)).into() @@ -158,34 +154,34 @@ impl IAccPropServices_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAccessible_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn accParent(&self) -> ::windows_core::Result; fn accChildCount(&self) -> ::windows_core::Result; - fn get_accChild(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn get_accName(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn get_accValue(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn get_accDescription(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn get_accRole(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn get_accState(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn get_accHelp(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: &super::super::System::Variant::VARIANT, pidtopic: *mut i32) -> ::windows_core::Result<()>; - fn get_accKeyboardShortcut(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn accFocus(&self) -> ::windows_core::Result; - fn accSelection(&self) -> ::windows_core::Result; - fn get_accDefaultAction(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; - fn accSelect(&self, flagsselect: i32, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn accNavigate(&self, navdir: i32, varstart: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result; - fn accDoDefaultAction(&self, varchild: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn put_accName(&self, varchild: &super::super::System::Variant::VARIANT, szname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn put_accValue(&self, varchild: &super::super::System::Variant::VARIANT, szvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + fn get_accChild(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result; + fn get_accName(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_accValue(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_accDescription(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_accRole(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn get_accState(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn get_accHelp(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: &::windows_core::VARIANT, pidtopic: *mut i32) -> ::windows_core::Result<()>; + fn get_accKeyboardShortcut(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn accFocus(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn accSelection(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn get_accDefaultAction(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn accSelect(&self, flagsselect: i32, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn accNavigate(&self, navdir: i32, varstart: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn accDoDefaultAction(&self, varchild: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn put_accName(&self, varchild: &::windows_core::VARIANT, szname: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn put_accValue(&self, varchild: &::windows_core::VARIANT, szvalue: &::windows_core::BSTR) -> ::windows_core::Result<()>; +} +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAccessible {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAccessible_Vtbl { pub const fn new, Impl: IAccessible_Impl, const OFFSET: isize>() -> IAccessible_Vtbl { unsafe extern "system" fn accParent, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdispparent: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -210,7 +206,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accChild, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, ppdispchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accChild, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdispchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accChild(::core::mem::transmute(&varchild)) { @@ -221,7 +217,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accName, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accName, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accName(::core::mem::transmute(&varchild)) { @@ -232,7 +228,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accValue, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accValue, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accValue(::core::mem::transmute(&varchild)) { @@ -243,7 +239,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accDescription, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accDescription, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accDescription(::core::mem::transmute(&varchild)) { @@ -254,7 +250,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accRole, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pvarrole: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accRole, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarrole: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accRole(::core::mem::transmute(&varchild)) { @@ -265,7 +261,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accState, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pvarstate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accState, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarstate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accState(::core::mem::transmute(&varchild)) { @@ -276,7 +272,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accHelp, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszhelp: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accHelp, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszhelp: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accHelp(::core::mem::transmute(&varchild)) { @@ -287,12 +283,12 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accHelpTopic, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varchild: super::super::System::Variant::VARIANT, pidtopic: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accHelpTopic, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pidtopic: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.get_accHelpTopic(::core::mem::transmute_copy(&pszhelpfile), ::core::mem::transmute(&varchild), ::core::mem::transmute_copy(&pidtopic)).into() } - unsafe extern "system" fn get_accKeyboardShortcut, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszkeyboardshortcut: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accKeyboardShortcut, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszkeyboardshortcut: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accKeyboardShortcut(::core::mem::transmute(&varchild)) { @@ -303,7 +299,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn accFocus, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accFocus, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarchild: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.accFocus() { @@ -314,7 +310,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn accSelection, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarchildren: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accSelection, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarchildren: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.accSelection() { @@ -325,7 +321,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn get_accDefaultAction, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_accDefaultAction, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_accDefaultAction(::core::mem::transmute(&varchild)) { @@ -336,17 +332,17 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn accSelect, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flagsselect: i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accSelect, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flagsselect: i32, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.accSelect(::core::mem::transmute_copy(&flagsselect), ::core::mem::transmute(&varchild)).into() } - unsafe extern "system" fn accLocation, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accLocation, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.accLocation(::core::mem::transmute_copy(&pxleft), ::core::mem::transmute_copy(&pytop), ::core::mem::transmute_copy(&pcxwidth), ::core::mem::transmute_copy(&pcyheight), ::core::mem::transmute(&varchild)).into() } - unsafe extern "system" fn accNavigate, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, navdir: i32, varstart: super::super::System::Variant::VARIANT, pvarendupat: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accNavigate, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, navdir: i32, varstart: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarendupat: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.accNavigate(::core::mem::transmute_copy(&navdir), ::core::mem::transmute(&varstart)) { @@ -357,7 +353,7 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn accHitTest, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xleft: i32, ytop: i32, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accHitTest, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, xleft: i32, ytop: i32, pvarchild: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.accHitTest(::core::mem::transmute_copy(&xleft), ::core::mem::transmute_copy(&ytop)) { @@ -368,17 +364,17 @@ impl IAccessible_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn accDoDefaultAction, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn accDoDefaultAction, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.accDoDefaultAction(::core::mem::transmute(&varchild)).into() } - unsafe extern "system" fn put_accName, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, szname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_accName, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, szname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_accName(::core::mem::transmute(&varchild), ::core::mem::transmute(&szname)).into() } - unsafe extern "system" fn put_accValue, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, szvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_accValue, Impl: IAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, szvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_accValue(::core::mem::transmute(&varchild), ::core::mem::transmute(&szvalue)).into() @@ -1041,17 +1037,13 @@ impl IInvokeProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IItemContainerProvider_Impl: Sized { - fn FindItemByProperty(&self, pstartafter: ::core::option::Option<&IRawElementProviderSimple>, propertyid: UIA_PROPERTY_ID, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn FindItemByProperty(&self, pstartafter: ::core::option::Option<&IRawElementProviderSimple>, propertyid: UIA_PROPERTY_ID, value: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IItemContainerProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IItemContainerProvider_Vtbl { pub const fn new, Impl: IItemContainerProvider_Impl, const OFFSET: isize>() -> IItemContainerProvider_Vtbl { - unsafe extern "system" fn FindItemByProperty, Impl: IItemContainerProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindItemByProperty, Impl: IItemContainerProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindItemByProperty(::windows_core::from_raw_borrowed(&pstartafter), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute(&value)) { @@ -1352,19 +1344,19 @@ impl IProxyProviderWinEventHandler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IProxyProviderWinEventSink_Impl: Sized { - fn AddAutomationPropertyChangedEvent(&self, pprovider: ::core::option::Option<&IRawElementProviderSimple>, id: UIA_PROPERTY_ID, newvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddAutomationPropertyChangedEvent(&self, pprovider: ::core::option::Option<&IRawElementProviderSimple>, id: UIA_PROPERTY_ID, newvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AddAutomationEvent(&self, pprovider: ::core::option::Option<&IRawElementProviderSimple>, id: UIA_EVENT_ID) -> ::windows_core::Result<()>; fn AddStructureChangedEvent(&self, pprovider: ::core::option::Option<&IRawElementProviderSimple>, structurechangetype: StructureChangeType, runtimeid: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IProxyProviderWinEventSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IProxyProviderWinEventSink_Vtbl { pub const fn new, Impl: IProxyProviderWinEventSink_Impl, const OFFSET: isize>() -> IProxyProviderWinEventSink_Vtbl { - unsafe extern "system" fn AddAutomationPropertyChangedEvent, Impl: IProxyProviderWinEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, id: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddAutomationPropertyChangedEvent, Impl: IProxyProviderWinEventSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, id: UIA_PROPERTY_ID, newvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddAutomationPropertyChangedEvent(::windows_core::from_raw_borrowed(&pprovider), ::core::mem::transmute_copy(&id), ::core::mem::transmute(&newvalue)).into() @@ -1700,17 +1692,13 @@ impl IRawElementProviderHwndOverride_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IRawElementProviderSimple_Impl: Sized { fn ProviderOptions(&self) -> ::windows_core::Result; fn GetPatternProvider(&self, patternid: UIA_PATTERN_ID) -> ::windows_core::Result<::windows_core::IUnknown>; - fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result; + fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT>; fn HostRawElementProvider(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRawElementProviderSimple {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IRawElementProviderSimple_Vtbl { pub const fn new, Impl: IRawElementProviderSimple_Impl, const OFFSET: isize>() -> IRawElementProviderSimple_Vtbl { unsafe extern "system" fn ProviderOptions, Impl: IRawElementProviderSimple_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pretval: *mut ProviderOptions) -> ::windows_core::HRESULT { @@ -1735,7 +1723,7 @@ impl IRawElementProviderSimple_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPropertyValue, Impl: IRawElementProviderSimple_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, pretval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropertyValue, Impl: IRawElementProviderSimple_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, pretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPropertyValue(::core::mem::transmute_copy(&propertyid)) { @@ -1769,14 +1757,10 @@ impl IRawElementProviderSimple_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IRawElementProviderSimple2_Impl: Sized + IRawElementProviderSimple_Impl { fn ShowContextMenu(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRawElementProviderSimple2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IRawElementProviderSimple2_Vtbl { pub const fn new, Impl: IRawElementProviderSimple2_Impl, const OFFSET: isize>() -> IRawElementProviderSimple2_Vtbl { unsafe extern "system" fn ShowContextMenu, Impl: IRawElementProviderSimple2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1790,17 +1774,13 @@ impl IRawElementProviderSimple2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IRawElementProviderSimple3_Impl: Sized + IRawElementProviderSimple2_Impl { - fn GetMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result; + fn GetMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRawElementProviderSimple3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IRawElementProviderSimple3_Vtbl { pub const fn new, Impl: IRawElementProviderSimple3_Impl, const OFFSET: isize>() -> IRawElementProviderSimple3_Vtbl { - unsafe extern "system" fn GetMetadataValue, Impl: IRawElementProviderSimple3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetMetadataValue, Impl: IRawElementProviderSimple3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetMetadataValue(::core::mem::transmute_copy(&targetid), ::core::mem::transmute_copy(&metadataid)) { @@ -2740,16 +2720,16 @@ impl ITextProvider2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextRangeProvider_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn Compare(&self, range: ::core::option::Option<&ITextRangeProvider>) -> ::windows_core::Result; fn CompareEndpoints(&self, endpoint: TextPatternRangeEndpoint, targetrange: ::core::option::Option<&ITextRangeProvider>, targetendpoint: TextPatternRangeEndpoint) -> ::windows_core::Result; fn ExpandToEnclosingUnit(&self, unit: TextUnit) -> ::windows_core::Result<()>; - fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: &super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL) -> ::windows_core::Result; + fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: &::windows_core::VARIANT, backward: super::super::Foundation::BOOL) -> ::windows_core::Result; fn FindText(&self, text: &::windows_core::BSTR, backward: super::super::Foundation::BOOL, ignorecase: super::super::Foundation::BOOL) -> ::windows_core::Result; - fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result; + fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetBoundingRectangles(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn GetEnclosingElement(&self) -> ::windows_core::Result; fn GetText(&self, maxlength: i32) -> ::windows_core::Result<::windows_core::BSTR>; @@ -2762,9 +2742,9 @@ pub trait ITextRangeProvider_Impl: Sized { fn ScrollIntoView(&self, aligntotop: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetChildren(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextRangeProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextRangeProvider_Vtbl { pub const fn new, Impl: ITextRangeProvider_Impl, const OFFSET: isize>() -> ITextRangeProvider_Vtbl { unsafe extern "system" fn Clone, Impl: ITextRangeProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2805,7 +2785,7 @@ impl ITextRangeProvider_Vtbl { let this = (*this).get_impl(); this.ExpandToEnclosingUnit(::core::mem::transmute_copy(&unit)).into() } - unsafe extern "system" fn FindAttribute, Impl: ITextRangeProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindAttribute, Impl: ITextRangeProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, backward: super::super::Foundation::BOOL, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindAttribute(::core::mem::transmute_copy(&attributeid), ::core::mem::transmute(&val), ::core::mem::transmute_copy(&backward)) { @@ -2827,7 +2807,7 @@ impl ITextRangeProvider_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetAttributeValue, Impl: ITextRangeProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, pretval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttributeValue, Impl: ITextRangeProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, pretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttributeValue(::core::mem::transmute_copy(&attributeid)) { @@ -2955,14 +2935,14 @@ impl ITextRangeProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextRangeProvider2_Impl: Sized + ITextRangeProvider_Impl { fn ShowContextMenu(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextRangeProvider2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextRangeProvider2_Vtbl { pub const fn new, Impl: ITextRangeProvider2_Impl, const OFFSET: isize>() -> ITextRangeProvider2_Vtbl { unsafe extern "system" fn ShowContextMenu, Impl: ITextRangeProvider2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3161,8 +3141,8 @@ impl ITransformProvider2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation_Impl: Sized { fn CompareElements(&self, el1: ::core::option::Option<&IUIAutomationElement>, el2: ::core::option::Option<&IUIAutomationElement>) -> ::windows_core::Result; fn CompareRuntimeIds(&self, runtimeid1: *const super::super::System::Com::SAFEARRAY, runtimeid2: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result; @@ -3184,8 +3164,8 @@ pub trait IUIAutomation_Impl: Sized { fn CreateCacheRequest(&self) -> ::windows_core::Result; fn CreateTrueCondition(&self) -> ::windows_core::Result; fn CreateFalseCondition(&self) -> ::windows_core::Result; - fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: &super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result; + fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: &::windows_core::VARIANT) -> ::windows_core::Result; + fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: &::windows_core::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result; fn CreateAndCondition(&self, condition1: ::core::option::Option<&IUIAutomationCondition>, condition2: ::core::option::Option<&IUIAutomationCondition>) -> ::windows_core::Result; fn CreateAndConditionFromArray(&self, conditions: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::Result; fn CreateAndConditionFromNativeArray(&self, conditions: *const ::core::option::Option, conditioncount: i32) -> ::windows_core::Result; @@ -3205,8 +3185,8 @@ pub trait IUIAutomation_Impl: Sized { fn RemoveAllEventHandlers(&self) -> ::windows_core::Result<()>; fn IntNativeArrayToSafeArray(&self, array: *const i32, arraycount: i32) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()>; - fn RectToVariant(&self, rc: &super::super::Foundation::RECT) -> ::windows_core::Result; - fn VariantToRect(&self, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn RectToVariant(&self, rc: &super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn VariantToRect(&self, var: &::windows_core::VARIANT) -> ::windows_core::Result; fn SafeArrayToRectNativeArray(&self, rects: *const super::super::System::Com::SAFEARRAY, rectarray: *mut *mut super::super::Foundation::RECT, rectarraycount: *mut i32) -> ::windows_core::Result<()>; fn CreateProxyFactoryEntry(&self, factory: ::core::option::Option<&IUIAutomationProxyFactory>) -> ::windows_core::Result; fn ProxyFactoryMapping(&self) -> ::windows_core::Result; @@ -3214,15 +3194,15 @@ pub trait IUIAutomation_Impl: Sized { fn GetPatternProgrammaticName(&self, pattern: UIA_PATTERN_ID) -> ::windows_core::Result<::windows_core::BSTR>; fn PollForPotentialSupportedPatterns(&self, pelement: ::core::option::Option<&IUIAutomationElement>, patternids: *mut *mut super::super::System::Com::SAFEARRAY, patternnames: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; fn PollForPotentialSupportedProperties(&self, pelement: ::core::option::Option<&IUIAutomationElement>, propertyids: *mut *mut super::super::System::Com::SAFEARRAY, propertynames: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::Result<()>; - fn CheckNotSupported(&self, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn CheckNotSupported(&self, value: &::windows_core::VARIANT) -> ::windows_core::Result; fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn ReservedMixedAttributeValue(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn ElementFromIAccessible(&self, accessible: ::core::option::Option<&IAccessible>, childid: i32) -> ::windows_core::Result; fn ElementFromIAccessibleBuildCache(&self, accessible: ::core::option::Option<&IAccessible>, childid: i32, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation_Vtbl { pub const fn new, Impl: IUIAutomation_Impl, const OFFSET: isize>() -> IUIAutomation_Vtbl { unsafe extern "system" fn CompareElements, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, el1: *mut ::core::ffi::c_void, el2: *mut ::core::ffi::c_void, aresame: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -3445,7 +3425,7 @@ impl IUIAutomation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreatePropertyCondition, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreatePropertyCondition, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreatePropertyCondition(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute(&value)) { @@ -3456,7 +3436,7 @@ impl IUIAutomation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CreatePropertyConditionEx, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreatePropertyConditionEx, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: PropertyConditionFlags, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreatePropertyConditionEx(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute(&value), ::core::mem::transmute_copy(&flags)) { @@ -3610,7 +3590,7 @@ impl IUIAutomation_Vtbl { let this = (*this).get_impl(); this.IntSafeArrayToNativeArray(::core::mem::transmute_copy(&intarray), ::core::mem::transmute_copy(&array), ::core::mem::transmute_copy(&arraycount)).into() } - unsafe extern "system" fn RectToVariant, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rc: super::super::Foundation::RECT, var: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn RectToVariant, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rc: super::super::Foundation::RECT, var: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RectToVariant(::core::mem::transmute(&rc)) { @@ -3621,7 +3601,7 @@ impl IUIAutomation_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn VariantToRect, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT, rc: *mut super::super::Foundation::RECT) -> ::windows_core::HRESULT { + unsafe extern "system" fn VariantToRect, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>, rc: *mut super::super::Foundation::RECT) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.VariantToRect(::core::mem::transmute(&var)) { @@ -3691,7 +3671,7 @@ impl IUIAutomation_Vtbl { let this = (*this).get_impl(); this.PollForPotentialSupportedProperties(::windows_core::from_raw_borrowed(&pelement), ::core::mem::transmute_copy(&propertyids), ::core::mem::transmute_copy(&propertynames)).into() } - unsafe extern "system" fn CheckNotSupported, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: super::super::System::Variant::VARIANT, isnotsupported: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn CheckNotSupported, Impl: IUIAutomation_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, isnotsupported: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CheckNotSupported(::core::mem::transmute(&value)) { @@ -3809,8 +3789,8 @@ impl IUIAutomation_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation2_Impl: Sized + IUIAutomation_Impl { fn AutoSetFocus(&self) -> ::windows_core::Result; fn SetAutoSetFocus(&self, autosetfocus: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; @@ -3819,9 +3799,9 @@ pub trait IUIAutomation2_Impl: Sized + IUIAutomation_Impl { fn TransactionTimeout(&self) -> ::windows_core::Result; fn SetTransactionTimeout(&self, timeout: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation2_Vtbl { pub const fn new, Impl: IUIAutomation2_Impl, const OFFSET: isize>() -> IUIAutomation2_Vtbl { unsafe extern "system" fn AutoSetFocus, Impl: IUIAutomation2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, autosetfocus: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -3886,15 +3866,15 @@ impl IUIAutomation2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation3_Impl: Sized + IUIAutomation2_Impl { fn AddTextEditTextChangedEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, scope: TreeScope, texteditchangetype: TextEditChangeType, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, handler: ::core::option::Option<&IUIAutomationTextEditTextChangedEventHandler>) -> ::windows_core::Result<()>; fn RemoveTextEditTextChangedEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, handler: ::core::option::Option<&IUIAutomationTextEditTextChangedEventHandler>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation3_Vtbl { pub const fn new, Impl: IUIAutomation3_Impl, const OFFSET: isize>() -> IUIAutomation3_Vtbl { unsafe extern "system" fn AddTextEditTextChangedEventHandler, Impl: IUIAutomation3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, element: *mut ::core::ffi::c_void, scope: TreeScope, texteditchangetype: TextEditChangeType, cacherequest: *mut ::core::ffi::c_void, handler: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3917,15 +3897,15 @@ impl IUIAutomation3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation4_Impl: Sized + IUIAutomation3_Impl { fn AddChangesEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, scope: TreeScope, changetypes: *const i32, changescount: i32, pcacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, handler: ::core::option::Option<&IUIAutomationChangesEventHandler>) -> ::windows_core::Result<()>; fn RemoveChangesEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, handler: ::core::option::Option<&IUIAutomationChangesEventHandler>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation4_Vtbl { pub const fn new, Impl: IUIAutomation4_Impl, const OFFSET: isize>() -> IUIAutomation4_Vtbl { unsafe extern "system" fn AddChangesEventHandler, Impl: IUIAutomation4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, element: *mut ::core::ffi::c_void, scope: TreeScope, changetypes: *const i32, changescount: i32, pcacherequest: *mut ::core::ffi::c_void, handler: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3948,15 +3928,15 @@ impl IUIAutomation4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation5_Impl: Sized + IUIAutomation4_Impl { fn AddNotificationEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, scope: TreeScope, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, handler: ::core::option::Option<&IUIAutomationNotificationEventHandler>) -> ::windows_core::Result<()>; fn RemoveNotificationEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, handler: ::core::option::Option<&IUIAutomationNotificationEventHandler>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation5_Vtbl { pub const fn new, Impl: IUIAutomation5_Impl, const OFFSET: isize>() -> IUIAutomation5_Vtbl { unsafe extern "system" fn AddNotificationEventHandler, Impl: IUIAutomation5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, element: *mut ::core::ffi::c_void, scope: TreeScope, cacherequest: *mut ::core::ffi::c_void, handler: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3979,8 +3959,8 @@ impl IUIAutomation5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomation6_Impl: Sized + IUIAutomation5_Impl { fn CreateEventHandlerGroup(&self) -> ::windows_core::Result; fn AddEventHandlerGroup(&self, element: ::core::option::Option<&IUIAutomationElement>, handlergroup: ::core::option::Option<&IUIAutomationEventHandlerGroup>) -> ::windows_core::Result<()>; @@ -3992,9 +3972,9 @@ pub trait IUIAutomation6_Impl: Sized + IUIAutomation5_Impl { fn AddActiveTextPositionChangedEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, scope: TreeScope, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, handler: ::core::option::Option<&IUIAutomationActiveTextPositionChangedEventHandler>) -> ::windows_core::Result<()>; fn RemoveActiveTextPositionChangedEventHandler(&self, element: ::core::option::Option<&IUIAutomationElement>, handler: ::core::option::Option<&IUIAutomationActiveTextPositionChangedEventHandler>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomation6 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomation6_Vtbl { pub const fn new, Impl: IUIAutomation6_Impl, const OFFSET: isize>() -> IUIAutomation6_Vtbl { unsafe extern "system" fn CreateEventHandlerGroup, Impl: IUIAutomation6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, handlergroup: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4413,14 +4393,10 @@ impl IUIAutomationCacheRequest_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUIAutomationChangesEventHandler_Impl: Sized { fn HandleChangesEvent(&self, sender: ::core::option::Option<&IUIAutomationElement>, uiachanges: *const UiaChangeInfo, changescount: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUIAutomationChangesEventHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUIAutomationChangesEventHandler_Vtbl { pub const fn new, Impl: IUIAutomationChangesEventHandler_Impl, const OFFSET: isize>() -> IUIAutomationChangesEventHandler_Vtbl { unsafe extern "system" fn HandleChangesEvent, Impl: IUIAutomationChangesEventHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, uiachanges: *const UiaChangeInfo, changescount: i32) -> ::windows_core::HRESULT { @@ -4703,8 +4679,8 @@ impl IUIAutomationDropTargetPattern_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement_Impl: Sized { fn SetFocus(&self) -> ::windows_core::Result<()>; fn GetRuntimeId(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; @@ -4713,10 +4689,10 @@ pub trait IUIAutomationElement_Impl: Sized { fn FindFirstBuildCache(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; fn FindAllBuildCache(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; fn BuildUpdatedCache(&self, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; - fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result; - fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL) -> ::windows_core::Result; - fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result; - fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL) -> ::windows_core::Result; + fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetCurrentPatternAs(&self, patternid: UIA_PATTERN_ID, riid: *const ::windows_core::GUID, patternobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetCachedPatternAs(&self, patternid: UIA_PATTERN_ID, riid: *const ::windows_core::GUID, patternobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetCurrentPattern(&self, patternid: UIA_PATTERN_ID) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -4789,9 +4765,9 @@ pub trait IUIAutomationElement_Impl: Sized { fn CachedProviderDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetClickablePoint(&self, clickable: *mut super::super::Foundation::POINT, gotclickable: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement_Vtbl { pub const fn new, Impl: IUIAutomationElement_Impl, const OFFSET: isize>() -> IUIAutomationElement_Vtbl { unsafe extern "system" fn SetFocus, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4865,7 +4841,7 @@ impl IUIAutomationElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCurrentPropertyValue, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCurrentPropertyValue, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCurrentPropertyValue(::core::mem::transmute_copy(&propertyid)) { @@ -4876,7 +4852,7 @@ impl IUIAutomationElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCurrentPropertyValueEx, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCurrentPropertyValueEx, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCurrentPropertyValueEx(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ignoredefaultvalue)) { @@ -4887,7 +4863,7 @@ impl IUIAutomationElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCachedPropertyValue, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCachedPropertyValue, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCachedPropertyValue(::core::mem::transmute_copy(&propertyid)) { @@ -4898,7 +4874,7 @@ impl IUIAutomationElement_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCachedPropertyValueEx, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCachedPropertyValueEx, Impl: IUIAutomationElement_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCachedPropertyValueEx(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&ignoredefaultvalue)) { @@ -5762,8 +5738,8 @@ impl IUIAutomationElement_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement2_Impl: Sized + IUIAutomationElement_Impl { fn CurrentOptimizeForVisualContent(&self) -> ::windows_core::Result; fn CachedOptimizeForVisualContent(&self) -> ::windows_core::Result; @@ -5772,9 +5748,9 @@ pub trait IUIAutomationElement2_Impl: Sized + IUIAutomationElement_Impl { fn CurrentFlowsFrom(&self) -> ::windows_core::Result; fn CachedFlowsFrom(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement2_Vtbl { pub const fn new, Impl: IUIAutomationElement2_Impl, const OFFSET: isize>() -> IUIAutomationElement2_Vtbl { unsafe extern "system" fn CurrentOptimizeForVisualContent, Impl: IUIAutomationElement2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -5857,16 +5833,16 @@ impl IUIAutomationElement2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement3_Impl: Sized + IUIAutomationElement2_Impl { fn ShowContextMenu(&self) -> ::windows_core::Result<()>; fn CurrentIsPeripheral(&self) -> ::windows_core::Result; fn CachedIsPeripheral(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement3_Vtbl { pub const fn new, Impl: IUIAutomationElement3_Impl, const OFFSET: isize>() -> IUIAutomationElement3_Vtbl { unsafe extern "system" fn ShowContextMenu, Impl: IUIAutomationElement3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5907,8 +5883,8 @@ impl IUIAutomationElement3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement4_Impl: Sized + IUIAutomationElement3_Impl { fn CurrentPositionInSet(&self) -> ::windows_core::Result; fn CurrentSizeOfSet(&self) -> ::windows_core::Result; @@ -5921,9 +5897,9 @@ pub trait IUIAutomationElement4_Impl: Sized + IUIAutomationElement3_Impl { fn CachedAnnotationTypes(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn CachedAnnotationObjects(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement4_Vtbl { pub const fn new, Impl: IUIAutomationElement4_Impl, const OFFSET: isize>() -> IUIAutomationElement4_Vtbl { unsafe extern "system" fn CurrentPositionInSet, Impl: IUIAutomationElement4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut i32) -> ::windows_core::HRESULT { @@ -6054,17 +6030,17 @@ impl IUIAutomationElement4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement5_Impl: Sized + IUIAutomationElement4_Impl { fn CurrentLandmarkType(&self) -> ::windows_core::Result; fn CurrentLocalizedLandmarkType(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CachedLandmarkType(&self) -> ::windows_core::Result; fn CachedLocalizedLandmarkType(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement5_Vtbl { pub const fn new, Impl: IUIAutomationElement5_Impl, const OFFSET: isize>() -> IUIAutomationElement5_Vtbl { unsafe extern "system" fn CurrentLandmarkType, Impl: IUIAutomationElement5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut UIA_LANDMARKTYPE_ID) -> ::windows_core::HRESULT { @@ -6123,15 +6099,15 @@ impl IUIAutomationElement5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement6_Impl: Sized + IUIAutomationElement5_Impl { fn CurrentFullDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn CachedFullDescription(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement6 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement6_Vtbl { pub const fn new, Impl: IUIAutomationElement6_Impl, const OFFSET: isize>() -> IUIAutomationElement6_Vtbl { unsafe extern "system" fn CurrentFullDescription, Impl: IUIAutomationElement6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6166,18 +6142,18 @@ impl IUIAutomationElement6_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement7_Impl: Sized + IUIAutomationElement6_Impl { fn FindFirstWithOptions(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, traversaloptions: TreeTraversalOptions, root: ::core::option::Option<&IUIAutomationElement>) -> ::windows_core::Result; fn FindAllWithOptions(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, traversaloptions: TreeTraversalOptions, root: ::core::option::Option<&IUIAutomationElement>) -> ::windows_core::Result; fn FindFirstWithOptionsBuildCache(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, traversaloptions: TreeTraversalOptions, root: ::core::option::Option<&IUIAutomationElement>) -> ::windows_core::Result; fn FindAllWithOptionsBuildCache(&self, scope: TreeScope, condition: ::core::option::Option<&IUIAutomationCondition>, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>, traversaloptions: TreeTraversalOptions, root: ::core::option::Option<&IUIAutomationElement>) -> ::windows_core::Result; - fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result; + fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement7 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement7_Vtbl { pub const fn new, Impl: IUIAutomationElement7_Impl, const OFFSET: isize>() -> IUIAutomationElement7_Vtbl { unsafe extern "system" fn FindFirstWithOptions, Impl: IUIAutomationElement7_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, traversaloptions: TreeTraversalOptions, root: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6224,7 +6200,7 @@ impl IUIAutomationElement7_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetCurrentMetadataValue, Impl: IUIAutomationElement7_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCurrentMetadataValue, Impl: IUIAutomationElement7_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCurrentMetadataValue(::core::mem::transmute_copy(&targetid), ::core::mem::transmute_copy(&metadataid)) { @@ -6248,15 +6224,15 @@ impl IUIAutomationElement7_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement8_Impl: Sized + IUIAutomationElement7_Impl { fn CurrentHeadingLevel(&self) -> ::windows_core::Result; fn CachedHeadingLevel(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement8 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement8_Vtbl { pub const fn new, Impl: IUIAutomationElement8_Impl, const OFFSET: isize>() -> IUIAutomationElement8_Vtbl { unsafe extern "system" fn CurrentHeadingLevel, Impl: IUIAutomationElement8_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut UIA_HEADINGLEVEL_ID) -> ::windows_core::HRESULT { @@ -6291,15 +6267,15 @@ impl IUIAutomationElement8_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationElement9_Impl: Sized + IUIAutomationElement8_Impl { fn CurrentIsDialog(&self) -> ::windows_core::Result; fn CachedIsDialog(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationElement9 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationElement9_Vtbl { pub const fn new, Impl: IUIAutomationElement9_Impl, const OFFSET: isize>() -> IUIAutomationElement9_Vtbl { unsafe extern "system" fn CurrentIsDialog, Impl: IUIAutomationElement9_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, retval: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -6760,17 +6736,13 @@ impl IUIAutomationInvokePattern_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUIAutomationItemContainerPattern_Impl: Sized { - fn FindItemByProperty(&self, pstartafter: ::core::option::Option<&IUIAutomationElement>, propertyid: UIA_PROPERTY_ID, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn FindItemByProperty(&self, pstartafter: ::core::option::Option<&IUIAutomationElement>, propertyid: UIA_PROPERTY_ID, value: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUIAutomationItemContainerPattern {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUIAutomationItemContainerPattern_Vtbl { pub const fn new, Impl: IUIAutomationItemContainerPattern_Impl, const OFFSET: isize>() -> IUIAutomationItemContainerPattern_Vtbl { - unsafe extern "system" fn FindItemByProperty, Impl: IUIAutomationItemContainerPattern_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindItemByProperty, Impl: IUIAutomationItemContainerPattern_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindItemByProperty(::windows_core::from_raw_borrowed(&pstartafter), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute(&value)) { @@ -7360,17 +7332,13 @@ impl IUIAutomationPatternInstance_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUIAutomationPropertyChangedEventHandler_Impl: Sized { - fn HandlePropertyChangedEvent(&self, sender: ::core::option::Option<&IUIAutomationElement>, propertyid: UIA_PROPERTY_ID, newvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn HandlePropertyChangedEvent(&self, sender: ::core::option::Option<&IUIAutomationElement>, propertyid: UIA_PROPERTY_ID, newvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUIAutomationPropertyChangedEventHandler {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUIAutomationPropertyChangedEventHandler_Vtbl { pub const fn new, Impl: IUIAutomationPropertyChangedEventHandler_Impl, const OFFSET: isize>() -> IUIAutomationPropertyChangedEventHandler_Vtbl { - unsafe extern "system" fn HandlePropertyChangedEvent, Impl: IUIAutomationPropertyChangedEventHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn HandlePropertyChangedEvent, Impl: IUIAutomationPropertyChangedEventHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, newvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.HandlePropertyChangedEvent(::windows_core::from_raw_borrowed(&sender), ::core::mem::transmute_copy(&propertyid), ::core::mem::transmute(&newvalue)).into() @@ -7384,16 +7352,12 @@ impl IUIAutomationPropertyChangedEventHandler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IUIAutomationPropertyCondition_Impl: Sized + IUIAutomationCondition_Impl { fn PropertyId(&self) -> ::windows_core::Result; - fn PropertyValue(&self) -> ::windows_core::Result; + fn PropertyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn PropertyConditionFlags(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IUIAutomationPropertyCondition {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IUIAutomationPropertyCondition_Vtbl { pub const fn new, Impl: IUIAutomationPropertyCondition_Impl, const OFFSET: isize>() -> IUIAutomationPropertyCondition_Vtbl { unsafe extern "system" fn PropertyId, Impl: IUIAutomationPropertyCondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: *mut UIA_PROPERTY_ID) -> ::windows_core::HRESULT { @@ -7407,7 +7371,7 @@ impl IUIAutomationPropertyCondition_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PropertyValue, Impl: IUIAutomationPropertyCondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PropertyValue, Impl: IUIAutomationPropertyCondition_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PropertyValue() { @@ -9203,16 +9167,16 @@ impl IUIAutomationTextPattern2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationTextRange_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn Compare(&self, range: ::core::option::Option<&IUIAutomationTextRange>) -> ::windows_core::Result; fn CompareEndpoints(&self, srcendpoint: TextPatternRangeEndpoint, range: ::core::option::Option<&IUIAutomationTextRange>, targetendpoint: TextPatternRangeEndpoint) -> ::windows_core::Result; fn ExpandToEnclosingUnit(&self, textunit: TextUnit) -> ::windows_core::Result<()>; - fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: &super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL) -> ::windows_core::Result; + fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: &::windows_core::VARIANT, backward: super::super::Foundation::BOOL) -> ::windows_core::Result; fn FindText(&self, text: &::windows_core::BSTR, backward: super::super::Foundation::BOOL, ignorecase: super::super::Foundation::BOOL) -> ::windows_core::Result; - fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result; + fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetBoundingRectangles(&self) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; fn GetEnclosingElement(&self) -> ::windows_core::Result; fn GetText(&self, maxlength: i32) -> ::windows_core::Result<::windows_core::BSTR>; @@ -9225,9 +9189,9 @@ pub trait IUIAutomationTextRange_Impl: Sized { fn ScrollIntoView(&self, aligntotop: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetChildren(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationTextRange {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationTextRange_Vtbl { pub const fn new, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>() -> IUIAutomationTextRange_Vtbl { unsafe extern "system" fn Clone, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, clonedrange: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9268,7 +9232,7 @@ impl IUIAutomationTextRange_Vtbl { let this = (*this).get_impl(); this.ExpandToEnclosingUnit(::core::mem::transmute_copy(&textunit)).into() } - unsafe extern "system" fn FindAttribute, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindAttribute, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, backward: super::super::Foundation::BOOL, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindAttribute(::core::mem::transmute_copy(&attr), ::core::mem::transmute(&val), ::core::mem::transmute_copy(&backward)) { @@ -9290,7 +9254,7 @@ impl IUIAutomationTextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetAttributeValue, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttributeValue, Impl: IUIAutomationTextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttributeValue(::core::mem::transmute_copy(&attr)) { @@ -9418,14 +9382,14 @@ impl IUIAutomationTextRange_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationTextRange2_Impl: Sized + IUIAutomationTextRange_Impl { fn ShowContextMenu(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationTextRange2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationTextRange2_Vtbl { pub const fn new, Impl: IUIAutomationTextRange2_Impl, const OFFSET: isize>() -> IUIAutomationTextRange2_Vtbl { unsafe extern "system" fn ShowContextMenu, Impl: IUIAutomationTextRange2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -9439,16 +9403,16 @@ impl IUIAutomationTextRange2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IUIAutomationTextRange3_Impl: Sized + IUIAutomationTextRange2_Impl { fn GetEnclosingElementBuildCache(&self, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; fn GetChildrenBuildCache(&self, cacherequest: ::core::option::Option<&IUIAutomationCacheRequest>) -> ::windows_core::Result; fn GetAttributeValues(&self, attributeids: *const UIA_TEXTATTRIBUTE_ID, attributeidcount: i32) -> ::windows_core::Result<*mut super::super::System::Com::SAFEARRAY>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IUIAutomationTextRange3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IUIAutomationTextRange3_Vtbl { pub const fn new, Impl: IUIAutomationTextRange3_Impl, const OFFSET: isize>() -> IUIAutomationTextRange3_Vtbl { unsafe extern "system" fn GetEnclosingElementBuildCache, Impl: IUIAutomationTextRange3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, enclosingelement: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/UI/Accessibility/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/Accessibility/mod.rs index c558f76466..55323bcf75 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Accessibility/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Accessibility/mod.rs @@ -15,32 +15,32 @@ where ::windows_targets::link!("oleacc.dll" "system" fn AccSetRunningUtilityState(hwndapp : super::super::Foundation:: HWND, dwutilitystatemask : u32, dwutilitystate : ACC_UTILITY_STATE_FLAGS) -> ::windows_core::HRESULT); AccSetRunningUtilityState(hwndapp.into_param().abi(), dwutilitystatemask, dwutilitystate).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn AccessibleChildren(pacccontainer: P0, ichildstart: i32, rgvarchildren: &mut [super::super::System::Variant::VARIANT], pcobtained: *mut i32) -> ::windows_core::Result<()> +pub unsafe fn AccessibleChildren(pacccontainer: P0, ichildstart: i32, rgvarchildren: &mut [::windows_core::VARIANT], pcobtained: *mut i32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("oleacc.dll" "system" fn AccessibleChildren(pacccontainer : * mut::core::ffi::c_void, ichildstart : i32, cchildren : i32, rgvarchildren : *mut super::super::System::Variant:: VARIANT, pcobtained : *mut i32) -> ::windows_core::HRESULT); + ::windows_targets::link!("oleacc.dll" "system" fn AccessibleChildren(pacccontainer : * mut::core::ffi::c_void, ichildstart : i32, cchildren : i32, rgvarchildren : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pcobtained : *mut i32) -> ::windows_core::HRESULT); AccessibleChildren(pacccontainer.into_param().abi(), ichildstart, rgvarchildren.len().try_into().unwrap(), ::core::mem::transmute(rgvarchildren.as_ptr()), pcobtained).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn AccessibleObjectFromEvent(hwnd: P0, dwid: u32, dwchildid: u32, ppacc: *mut ::core::option::Option, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> +pub unsafe fn AccessibleObjectFromEvent(hwnd: P0, dwid: u32, dwchildid: u32, ppacc: *mut ::core::option::Option, pvarchild: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("oleacc.dll" "system" fn AccessibleObjectFromEvent(hwnd : super::super::Foundation:: HWND, dwid : u32, dwchildid : u32, ppacc : *mut * mut::core::ffi::c_void, pvarchild : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - AccessibleObjectFromEvent(hwnd.into_param().abi(), dwid, dwchildid, ::core::mem::transmute(ppacc), pvarchild).ok() + ::windows_targets::link!("oleacc.dll" "system" fn AccessibleObjectFromEvent(hwnd : super::super::Foundation:: HWND, dwid : u32, dwchildid : u32, ppacc : *mut * mut::core::ffi::c_void, pvarchild : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + AccessibleObjectFromEvent(hwnd.into_param().abi(), dwid, dwchildid, ::core::mem::transmute(ppacc), ::core::mem::transmute(pvarchild)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn AccessibleObjectFromPoint(ptscreen: super::super::Foundation::POINT, ppacc: *mut ::core::option::Option, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("oleacc.dll" "system" fn AccessibleObjectFromPoint(ptscreen : super::super::Foundation:: POINT, ppacc : *mut * mut::core::ffi::c_void, pvarchild : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - AccessibleObjectFromPoint(::core::mem::transmute(ptscreen), ::core::mem::transmute(ppacc), pvarchild).ok() +pub unsafe fn AccessibleObjectFromPoint(ptscreen: super::super::Foundation::POINT, ppacc: *mut ::core::option::Option, pvarchild: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("oleacc.dll" "system" fn AccessibleObjectFromPoint(ptscreen : super::super::Foundation:: POINT, ppacc : *mut * mut::core::ffi::c_void, pvarchild : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + AccessibleObjectFromPoint(::core::mem::transmute(ptscreen), ::core::mem::transmute(ppacc), ::core::mem::transmute(pvarchild)).ok() } #[inline] pub unsafe fn AccessibleObjectFromWindow(hwnd: P0, dwid: u32, riid: *const ::windows_core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> @@ -146,16 +146,15 @@ pub unsafe fn IsWinEventHookInstalled(event: u32) -> super::super::Foundation::B ::windows_targets::link!("user32.dll" "system" fn IsWinEventHookInstalled(event : u32) -> super::super::Foundation:: BOOL); IsWinEventHookInstalled(event) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn ItemContainerPattern_FindItemByProperty(hobj: P0, hnodestartafter: P1, propertyid: i32, value: super::super::System::Variant::VARIANT, pfound: *mut HUIANODE) -> ::windows_core::Result<()> +pub unsafe fn ItemContainerPattern_FindItemByProperty(hobj: P0, hnodestartafter: P1, propertyid: i32, value: P2, pfound: *mut HUIANODE) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn ItemContainerPattern_FindItemByProperty(hobj : HUIAPATTERNOBJECT, hnodestartafter : HUIANODE, propertyid : i32, value : super::super::System::Variant:: VARIANT, pfound : *mut HUIANODE) -> ::windows_core::HRESULT); - ItemContainerPattern_FindItemByProperty(hobj.into_param().abi(), hnodestartafter.into_param().abi(), propertyid, ::core::mem::transmute(value), pfound).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn ItemContainerPattern_FindItemByProperty(hobj : HUIAPATTERNOBJECT, hnodestartafter : HUIANODE, propertyid : i32, value : ::std::mem::MaybeUninit <::windows_core::VARIANT >, pfound : *mut HUIANODE) -> ::windows_core::HRESULT); + ItemContainerPattern_FindItemByProperty(hobj.into_param().abi(), hnodestartafter.into_param().abi(), propertyid, value.into_param().abi(), pfound).ok() } #[inline] pub unsafe fn LegacyIAccessiblePattern_DoDefaultAction(hobj: P0) -> ::windows_core::Result<()> @@ -431,16 +430,15 @@ where ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_ExpandToEnclosingUnit(hobj : HUIATEXTRANGE, unit : TextUnit) -> ::windows_core::HRESULT); TextRange_ExpandToEnclosingUnit(hobj.into_param().abi(), unit).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn TextRange_FindAttribute(hobj: P0, attributeid: i32, val: super::super::System::Variant::VARIANT, backward: P1, pretval: *mut HUIATEXTRANGE) -> ::windows_core::Result<()> +pub unsafe fn TextRange_FindAttribute(hobj: P0, attributeid: i32, val: P1, backward: P2, pretval: *mut HUIATEXTRANGE) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, - P1: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_FindAttribute(hobj : HUIATEXTRANGE, attributeid : i32, val : super::super::System::Variant:: VARIANT, backward : super::super::Foundation:: BOOL, pretval : *mut HUIATEXTRANGE) -> ::windows_core::HRESULT); - TextRange_FindAttribute(hobj.into_param().abi(), attributeid, ::core::mem::transmute(val), backward.into_param().abi(), pretval).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_FindAttribute(hobj : HUIATEXTRANGE, attributeid : i32, val : ::std::mem::MaybeUninit <::windows_core::VARIANT >, backward : super::super::Foundation:: BOOL, pretval : *mut HUIATEXTRANGE) -> ::windows_core::HRESULT); + TextRange_FindAttribute(hobj.into_param().abi(), attributeid, val.into_param().abi(), backward.into_param().abi(), pretval).ok() } #[inline] pub unsafe fn TextRange_FindText(hobj: P0, text: P1, backward: P2, ignorecase: P3, pretval: *mut HUIATEXTRANGE) -> ::windows_core::Result<()> @@ -453,15 +451,13 @@ where ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_FindText(hobj : HUIATEXTRANGE, text : ::std::mem::MaybeUninit <::windows_core::BSTR >, backward : super::super::Foundation:: BOOL, ignorecase : super::super::Foundation:: BOOL, pretval : *mut HUIATEXTRANGE) -> ::windows_core::HRESULT); TextRange_FindText(hobj.into_param().abi(), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), pretval).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn TextRange_GetAttributeValue(hobj: P0, attributeid: i32, pretval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> +pub unsafe fn TextRange_GetAttributeValue(hobj: P0, attributeid: i32, pretval: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_GetAttributeValue(hobj : HUIATEXTRANGE, attributeid : i32, pretval : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - TextRange_GetAttributeValue(hobj.into_param().abi(), attributeid, pretval).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn TextRange_GetAttributeValue(hobj : HUIATEXTRANGE, attributeid : i32, pretval : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + TextRange_GetAttributeValue(hobj.into_param().abi(), attributeid, ::core::mem::transmute(pretval)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -650,15 +646,13 @@ where ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaGetPatternProvider(hnode : HUIANODE, patternid : i32, phobj : *mut HUIAPATTERNOBJECT) -> ::windows_core::HRESULT); UiaGetPatternProvider(hnode.into_param().abi(), patternid, phobj).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn UiaGetPropertyValue(hnode: P0, propertyid: i32, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> +pub unsafe fn UiaGetPropertyValue(hnode: P0, propertyid: i32, pvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaGetPropertyValue(hnode : HUIANODE, propertyid : i32, pvalue : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - UiaGetPropertyValue(hnode.into_param().abi(), propertyid, pvalue).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaGetPropertyValue(hnode : HUIANODE, propertyid : i32, pvalue : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + UiaGetPropertyValue(hnode.into_param().abi(), propertyid, ::core::mem::transmute(pvalue)).ok() } #[inline] pub unsafe fn UiaGetReservedMixedAttributeValue() -> ::windows_core::Result<::windows_core::IUnknown> { @@ -697,26 +691,20 @@ where ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaGetUpdatedCache(hnode : HUIANODE, prequest : *mut UiaCacheRequest, normalizestate : NormalizeState, pnormalizecondition : *mut UiaCondition, pprequesteddata : *mut *mut super::super::System::Com:: SAFEARRAY, pptreestructure : *mut ::std::mem::MaybeUninit <::windows_core::BSTR >) -> ::windows_core::HRESULT); UiaGetUpdatedCache(hnode.into_param().abi(), prequest, normalizestate, pnormalizecondition, pprequesteddata, ::core::mem::transmute(pptreestructure)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn UiaHPatternObjectFromVariant(pvar: *mut super::super::System::Variant::VARIANT, phobj: *mut HUIAPATTERNOBJECT) -> ::windows_core::Result<()> { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHPatternObjectFromVariant(pvar : *mut super::super::System::Variant:: VARIANT, phobj : *mut HUIAPATTERNOBJECT) -> ::windows_core::HRESULT); - UiaHPatternObjectFromVariant(pvar, phobj).ok() +pub unsafe fn UiaHPatternObjectFromVariant(pvar: *mut ::windows_core::VARIANT, phobj: *mut HUIAPATTERNOBJECT) -> ::windows_core::Result<()> { + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHPatternObjectFromVariant(pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, phobj : *mut HUIAPATTERNOBJECT) -> ::windows_core::HRESULT); + UiaHPatternObjectFromVariant(::core::mem::transmute(pvar), phobj).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn UiaHTextRangeFromVariant(pvar: *mut super::super::System::Variant::VARIANT, phtextrange: *mut HUIATEXTRANGE) -> ::windows_core::Result<()> { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHTextRangeFromVariant(pvar : *mut super::super::System::Variant:: VARIANT, phtextrange : *mut HUIATEXTRANGE) -> ::windows_core::HRESULT); - UiaHTextRangeFromVariant(pvar, phtextrange).ok() +pub unsafe fn UiaHTextRangeFromVariant(pvar: *mut ::windows_core::VARIANT, phtextrange: *mut HUIATEXTRANGE) -> ::windows_core::Result<()> { + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHTextRangeFromVariant(pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, phtextrange : *mut HUIATEXTRANGE) -> ::windows_core::HRESULT); + UiaHTextRangeFromVariant(::core::mem::transmute(pvar), phtextrange).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn UiaHUiaNodeFromVariant(pvar: *mut super::super::System::Variant::VARIANT, phnode: *mut HUIANODE) -> ::windows_core::Result<()> { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHUiaNodeFromVariant(pvar : *mut super::super::System::Variant:: VARIANT, phnode : *mut HUIANODE) -> ::windows_core::HRESULT); - UiaHUiaNodeFromVariant(pvar, phnode).ok() +pub unsafe fn UiaHUiaNodeFromVariant(pvar: *mut ::windows_core::VARIANT, phnode: *mut HUIANODE) -> ::windows_core::Result<()> { + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaHUiaNodeFromVariant(pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, phnode : *mut HUIANODE) -> ::windows_core::HRESULT); + UiaHUiaNodeFromVariant(::core::mem::transmute(pvar), phnode).ok() } #[inline] pub unsafe fn UiaHasServerSideProvider(hwnd: P0) -> super::super::Foundation::BOOL @@ -735,15 +723,15 @@ where let mut result__ = ::std::mem::zeroed(); UiaHostProviderFromHwnd(hwnd.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] #[inline] -pub unsafe fn UiaIAccessibleFromProvider(pprovider: P0, dwflags: u32, ppaccessible: *mut ::core::option::Option, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> +pub unsafe fn UiaIAccessibleFromProvider(pprovider: P0, dwflags: u32, ppaccessible: *mut ::core::option::Option, pvarchild: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaIAccessibleFromProvider(pprovider : * mut::core::ffi::c_void, dwflags : u32, ppaccessible : *mut * mut::core::ffi::c_void, pvarchild : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - UiaIAccessibleFromProvider(pprovider.into_param().abi(), dwflags, ::core::mem::transmute(ppaccessible), pvarchild).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaIAccessibleFromProvider(pprovider : * mut::core::ffi::c_void, dwflags : u32, ppaccessible : *mut * mut::core::ffi::c_void, pvarchild : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + UiaIAccessibleFromProvider(pprovider.into_param().abi(), dwflags, ::core::mem::transmute(ppaccessible), ::core::mem::transmute(pvarchild)).ok() } #[inline] pub unsafe fn UiaLookupId(r#type: AutomationIdentifierType, pguid: *const ::windows_core::GUID) -> i32 { @@ -851,18 +839,16 @@ where ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaRaiseAutomationEvent(pprovider : * mut::core::ffi::c_void, id : UIA_EVENT_ID) -> ::windows_core::HRESULT); UiaRaiseAutomationEvent(pprovider.into_param().abi(), id).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn UiaRaiseAutomationPropertyChangedEvent(pprovider: P0, id: UIA_PROPERTY_ID, oldvalue: super::super::System::Variant::VARIANT, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> +pub unsafe fn UiaRaiseAutomationPropertyChangedEvent(pprovider: P0, id: UIA_PROPERTY_ID, oldvalue: P1, newvalue: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaRaiseAutomationPropertyChangedEvent(pprovider : * mut::core::ffi::c_void, id : UIA_PROPERTY_ID, oldvalue : super::super::System::Variant:: VARIANT, newvalue : super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); - UiaRaiseAutomationPropertyChangedEvent(pprovider.into_param().abi(), id, ::core::mem::transmute(oldvalue), ::core::mem::transmute(newvalue)).ok() + ::windows_targets::link!("uiautomationcore.dll" "system" fn UiaRaiseAutomationPropertyChangedEvent(pprovider : * mut::core::ffi::c_void, id : UIA_PROPERTY_ID, oldvalue : ::std::mem::MaybeUninit <::windows_core::VARIANT >, newvalue : ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); + UiaRaiseAutomationPropertyChangedEvent(pprovider.into_param().abi(), id, oldvalue.into_param().abi(), newvalue.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] #[inline] pub unsafe fn UiaRaiseChangesEvent(pprovider: P0, eventidcount: i32, puiachanges: *mut UiaChangeInfo) -> ::windows_core::Result<()> where @@ -1036,28 +1022,24 @@ pub struct IAccIdentity_Vtbl { ::windows_core::imp::com_interface!(IAccPropServer, IAccPropServer_Vtbl, 0x76c0dbbb_15e0_4e7b_b61b_20eeea2001e0); ::windows_core::imp::interface_hierarchy!(IAccPropServer, ::windows_core::IUnknown); impl IAccPropServer { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropValue(&self, pidstring: &[u8], idprop: ::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetPropValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), ::core::mem::transmute(idprop), pvarvalue, pfhasprop).ok() + pub unsafe fn GetPropValue(&self, pidstring: &[u8], idprop: ::windows_core::GUID, pvarvalue: *mut ::windows_core::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetPropValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), ::core::mem::transmute(idprop), ::core::mem::transmute(pvarvalue), pfhasprop).ok() } } #[repr(C)] #[doc(hidden)] pub struct IAccPropServer_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPropValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPropValue: usize, + pub GetPropValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfhasprop: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IAccPropServices, IAccPropServices_Vtbl, 0x6e26e776_04f0_495d_80e4_3330352e3169); ::windows_core::imp::interface_hierarchy!(IAccPropServices, ::windows_core::IUnknown); impl IAccPropServices { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPropValue(&self, pidstring: &[u8], idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetPropValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), ::core::mem::transmute(idprop), ::core::mem::transmute(var)).ok() + pub unsafe fn SetPropValue(&self, pidstring: &[u8], idprop: ::windows_core::GUID, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetPropValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), ::core::mem::transmute(idprop), var.into_param().abi()).ok() } pub unsafe fn SetPropServer(&self, pidstring: &[u8], paprops: &[::windows_core::GUID], pserver: P0, annoscope: AnnoScope) -> ::windows_core::Result<()> where @@ -1068,13 +1050,12 @@ impl IAccPropServices { pub unsafe fn ClearProps(&self, pidstring: &[u8], paprops: &[::windows_core::GUID]) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ClearProps)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), ::core::mem::transmute(paprops.as_ptr()), paprops.len().try_into().unwrap()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetHwndProp(&self, hwnd: P0, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetHwndProp(&self, hwnd: P0, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetHwndProp)(::windows_core::Interface::as_raw(self), hwnd.into_param().abi(), idobject, idchild, ::core::mem::transmute(idprop), ::core::mem::transmute(var)).ok() + (::windows_core::Interface::vtable(self).SetHwndProp)(::windows_core::Interface::as_raw(self), hwnd.into_param().abi(), idobject, idchild, ::core::mem::transmute(idprop), var.into_param().abi()).ok() } pub unsafe fn SetHwndPropStr(&self, hwnd: P0, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, str: P1) -> ::windows_core::Result<()> where @@ -1105,13 +1086,14 @@ impl IAccPropServices { pub unsafe fn DecomposeHwndIdentityString(&self, pidstring: &[u8], phwnd: *mut super::super::Foundation::HWND, pidobject: *mut u32, pidchild: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DecomposeHwndIdentityString)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pidstring.as_ptr()), pidstring.len().try_into().unwrap(), phwnd, pidobject, pidchild).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] - pub unsafe fn SetHmenuProp(&self, hmenu: P0, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_UI_WindowsAndMessaging\"`"] + #[cfg(feature = "Win32_UI_WindowsAndMessaging")] + pub unsafe fn SetHmenuProp(&self, hmenu: P0, idchild: u32, idprop: ::windows_core::GUID, var: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).SetHmenuProp)(::windows_core::Interface::as_raw(self), hmenu.into_param().abi(), idchild, ::core::mem::transmute(idprop), ::core::mem::transmute(var)).ok() + (::windows_core::Interface::vtable(self).SetHmenuProp)(::windows_core::Interface::as_raw(self), hmenu.into_param().abi(), idchild, ::core::mem::transmute(idprop), var.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_UI_WindowsAndMessaging\"`"] #[cfg(feature = "Win32_UI_WindowsAndMessaging")] @@ -1157,24 +1139,18 @@ impl IAccPropServices { #[doc(hidden)] pub struct IAccPropServices_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPropValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPropValue: usize, + pub SetPropValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetPropServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, paprops: *const ::windows_core::GUID, cprops: i32, pserver: *mut ::core::ffi::c_void, annoscope: AnnoScope) -> ::windows_core::HRESULT, pub ClearProps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, paprops: *const ::windows_core::GUID, cprops: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetHwndProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetHwndProp: usize, + pub SetHwndProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetHwndPropStr: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, idprop: ::windows_core::GUID, str: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub SetHwndPropServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32, pserver: *mut ::core::ffi::c_void, annoscope: AnnoScope) -> ::windows_core::HRESULT, pub ClearHwndProps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, paprops: *const ::windows_core::GUID, cprops: i32) -> ::windows_core::HRESULT, pub ComposeHwndIdentityString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, idobject: u32, idchild: u32, ppidstring: *mut *mut u8, pdwidstringlen: *mut u32) -> ::windows_core::HRESULT, pub DecomposeHwndIdentityString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidstring: *const u8, dwidstringlen: u32, phwnd: *mut super::super::Foundation::HWND, pidobject: *mut u32, pidchild: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] - pub SetHmenuProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: ::windows_core::GUID, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging")))] + #[cfg(feature = "Win32_UI_WindowsAndMessaging")] + pub SetHmenuProp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: ::windows_core::GUID, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_WindowsAndMessaging"))] SetHmenuProp: usize, #[cfg(feature = "Win32_UI_WindowsAndMessaging")] pub SetHmenuPropStr: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hmenu: super::WindowsAndMessaging::HMENU, idchild: u32, idprop: ::windows_core::GUID, str: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, @@ -1218,119 +1194,127 @@ impl IAccessible { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).accChildCount)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accChild(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn get_accChild(&self, varchild: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accChild)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accChild)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accName(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accName(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accName)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accValue(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accValue(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accValue)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accDescription(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accDescription(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accDescription)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accRole(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn get_accRole(&self, varchild: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accRole)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accRole)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accState(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn get_accState(&self, varchild: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accState)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accState)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accHelp(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accHelp(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accHelp)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accHelp)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: super::super::System::Variant::VARIANT, pidtopic: *mut i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).get_accHelpTopic)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pszhelpfile), ::core::mem::transmute(varchild), pidtopic).ok() + pub unsafe fn get_accHelpTopic(&self, pszhelpfile: *mut ::windows_core::BSTR, varchild: P0, pidtopic: *mut i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).get_accHelpTopic)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pszhelpfile), varchild.into_param().abi(), pidtopic).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accKeyboardShortcut(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accKeyboardShortcut(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accKeyboardShortcut)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accKeyboardShortcut)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accFocus(&self) -> ::windows_core::Result { + pub unsafe fn accFocus(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).accFocus)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accSelection(&self) -> ::windows_core::Result { + pub unsafe fn accSelection(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).accSelection)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_accDefaultAction(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn get_accDefaultAction(&self, varchild: P0) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).get_accDefaultAction)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).get_accDefaultAction)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accSelect(&self, flagsselect: i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).accSelect)(::windows_core::Interface::as_raw(self), flagsselect, ::core::mem::transmute(varchild)).ok() + pub unsafe fn accSelect(&self, flagsselect: i32, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).accSelect)(::windows_core::Interface::as_raw(self), flagsselect, varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).accLocation)(::windows_core::Interface::as_raw(self), pxleft, pytop, pcxwidth, pcyheight, ::core::mem::transmute(varchild)).ok() + pub unsafe fn accLocation(&self, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).accLocation)(::windows_core::Interface::as_raw(self), pxleft, pytop, pcxwidth, pcyheight, varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accNavigate(&self, navdir: i32, varstart: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn accNavigate(&self, navdir: i32, varstart: P0) -> ::windows_core::Result<::windows_core::VARIANT> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).accNavigate)(::windows_core::Interface::as_raw(self), navdir, ::core::mem::transmute(varstart), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).accNavigate)(::windows_core::Interface::as_raw(self), navdir, varstart.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result { + pub unsafe fn accHitTest(&self, xleft: i32, ytop: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).accHitTest)(::windows_core::Interface::as_raw(self), xleft, ytop, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn accDoDefaultAction(&self, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).accDoDefaultAction)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild)).ok() + pub unsafe fn accDoDefaultAction(&self, varchild: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).accDoDefaultAction)(::windows_core::Interface::as_raw(self), varchild.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_accName(&self, varchild: super::super::System::Variant::VARIANT, szname: P0) -> ::windows_core::Result<()> + pub unsafe fn put_accName(&self, varchild: P0, szname: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).put_accName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), szname.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).put_accName)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), szname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_accValue(&self, varchild: super::super::System::Variant::VARIANT, szvalue: P0) -> ::windows_core::Result<()> + pub unsafe fn put_accValue(&self, varchild: P0, szvalue: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).put_accValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varchild), szvalue.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).put_accValue)(::windows_core::Interface::as_raw(self), varchild.into_param().abi(), szvalue.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -1343,82 +1327,28 @@ pub struct IAccessible_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] accParent: usize, pub accChildCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcountchildren: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accChild: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, ppdispchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub get_accChild: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppdispchild: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] get_accChild: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accDescription: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pvarrole: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accRole: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pvarstate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accState: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accHelp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszhelp: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accHelp: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accHelpTopic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varchild: super::super::System::Variant::VARIANT, pidtopic: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accHelpTopic: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accKeyboardShortcut: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszkeyboardshortcut: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accKeyboardShortcut: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accFocus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accFocus: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarchildren: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accSelection: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_accDefaultAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, pszdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_accDefaultAction: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accSelect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flagsselect: i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accSelect: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accLocation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accNavigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, navdir: i32, varstart: super::super::System::Variant::VARIANT, pvarendupat: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accNavigate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accHitTest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, xleft: i32, ytop: i32, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accHitTest: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub accDoDefaultAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - accDoDefaultAction: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_accName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, szname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_accName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_accValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: super::super::System::Variant::VARIANT, szvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_accValue: usize, + pub get_accName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub get_accValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub get_accDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszdescription: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub get_accRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarrole: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub get_accState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarstate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub get_accHelp: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszhelp: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub get_accHelpTopic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszhelpfile: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pidtopic: *mut i32) -> ::windows_core::HRESULT, + pub get_accKeyboardShortcut: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszkeyboardshortcut: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub accFocus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarchild: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub accSelection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarchildren: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub get_accDefaultAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pszdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub accSelect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flagsselect: i32, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub accLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pxleft: *mut i32, pytop: *mut i32, pcxwidth: *mut i32, pcyheight: *mut i32, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub accNavigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, navdir: i32, varstart: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarendupat: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub accHitTest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, xleft: i32, ytop: i32, pvarchild: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub accDoDefaultAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub put_accName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, szname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + pub put_accValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varchild: ::std::mem::MaybeUninit<::windows_core::VARIANT>, szvalue: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IAccessibleEx, IAccessibleEx_Vtbl, 0xf8b80ada_2c44_48d0_89be_5ff23c9cd875); ::windows_core::imp::interface_hierarchy!(IAccessibleEx, ::windows_core::IUnknown); @@ -1779,24 +1709,20 @@ pub struct IInvokeProvider_Vtbl { ::windows_core::imp::com_interface!(IItemContainerProvider, IItemContainerProvider_Vtbl, 0xe747770b_39ce_4382_ab30_d8fb3f336f24); ::windows_core::imp::interface_hierarchy!(IItemContainerProvider, ::windows_core::IUnknown); impl IItemContainerProvider { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindItemByProperty(&self, pstartafter: P0, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn FindItemByProperty(&self, pstartafter: P0, propertyid: UIA_PROPERTY_ID, value: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindItemByProperty)(::windows_core::Interface::as_raw(self), pstartafter.into_param().abi(), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindItemByProperty)(::windows_core::Interface::as_raw(self), pstartafter.into_param().abi(), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] #[doc(hidden)] pub struct IItemContainerProvider_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindItemByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FindItemByProperty: usize, + pub FindItemByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ILegacyIAccessibleProvider, ILegacyIAccessibleProvider_Vtbl, 0xe44c3566_915d_4070_99c6_047bff5a08f5); ::windows_core::imp::interface_hierarchy!(ILegacyIAccessibleProvider, ::windows_core::IUnknown); @@ -1954,13 +1880,12 @@ pub struct IProxyProviderWinEventHandler_Vtbl { ::windows_core::imp::com_interface!(IProxyProviderWinEventSink, IProxyProviderWinEventSink_Vtbl, 0x4fd82b78_a43e_46ac_9803_0a6969c7c183); ::windows_core::imp::interface_hierarchy!(IProxyProviderWinEventSink, ::windows_core::IUnknown); impl IProxyProviderWinEventSink { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddAutomationPropertyChangedEvent(&self, pprovider: P0, id: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddAutomationPropertyChangedEvent(&self, pprovider: P0, id: UIA_PROPERTY_ID, newvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).AddAutomationPropertyChangedEvent)(::windows_core::Interface::as_raw(self), pprovider.into_param().abi(), id, ::core::mem::transmute(newvalue)).ok() + (::windows_core::Interface::vtable(self).AddAutomationPropertyChangedEvent)(::windows_core::Interface::as_raw(self), pprovider.into_param().abi(), id, newvalue.into_param().abi()).ok() } pub unsafe fn AddAutomationEvent(&self, pprovider: P0, id: UIA_EVENT_ID) -> ::windows_core::Result<()> where @@ -1981,10 +1906,7 @@ impl IProxyProviderWinEventSink { #[doc(hidden)] pub struct IProxyProviderWinEventSink_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddAutomationPropertyChangedEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, id: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddAutomationPropertyChangedEvent: usize, + pub AddAutomationPropertyChangedEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, id: UIA_PROPERTY_ID, newvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AddAutomationEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, id: UIA_EVENT_ID) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub AddStructureChangedEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pprovider: *mut ::core::ffi::c_void, structurechangetype: StructureChangeType, runtimeid: *const super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT, @@ -2175,9 +2097,7 @@ impl IRawElementProviderSimple { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPatternProvider)(::windows_core::Interface::as_raw(self), patternid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } @@ -2192,10 +2112,7 @@ pub struct IRawElementProviderSimple_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub ProviderOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pretval: *mut ProviderOptions) -> ::windows_core::HRESULT, pub GetPatternProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, patternid: UIA_PATTERN_ID, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, pretval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPropertyValue: usize, + pub GetPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, pretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub HostRawElementProvider: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IRawElementProviderSimple2, IRawElementProviderSimple2_Vtbl, 0xa0a839a9_8da1_4a82_806a_8e0d44e79f56); @@ -2209,9 +2126,7 @@ impl IRawElementProviderSimple2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPatternProvider)(::windows_core::Interface::as_raw(self), patternid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } @@ -2240,9 +2155,7 @@ impl IRawElementProviderSimple3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetPatternProvider)(::windows_core::Interface::as_raw(self), patternid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } @@ -2253,9 +2166,7 @@ impl IRawElementProviderSimple3 { pub unsafe fn ShowContextMenu(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ShowContextMenu)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result { + pub unsafe fn GetMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetMetadataValue)(::windows_core::Interface::as_raw(self), targetid, metadataid, &mut result__).from_abi(result__) } @@ -2264,10 +2175,7 @@ impl IRawElementProviderSimple3 { #[doc(hidden)] pub struct IRawElementProviderSimple3_Vtbl { pub base__: IRawElementProviderSimple2_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetMetadataValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetMetadataValue: usize, + pub GetMetadataValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IRawElementProviderWindowlessSite, IRawElementProviderWindowlessSite_Vtbl, 0x0a2a93cc_bfad_42ac_9b2e_0991fb0d3ea0); ::windows_core::imp::interface_hierarchy!(IRawElementProviderWindowlessSite, ::windows_core::IUnknown); @@ -2862,14 +2770,13 @@ impl ITextRangeProvider { pub unsafe fn ExpandToEnclosingUnit(&self, unit: TextUnit) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ExpandToEnclosingUnit)(::windows_core::Interface::as_raw(self), unit).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: P0) -> ::windows_core::Result + pub unsafe fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: P0, backward: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindAttribute)(::windows_core::Interface::as_raw(self), attributeid, ::core::mem::transmute(val), backward.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindAttribute)(::windows_core::Interface::as_raw(self), attributeid, val.into_param().abi(), backward.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, text: P0, backward: P1, ignorecase: P2) -> ::windows_core::Result where @@ -2880,9 +2787,7 @@ impl ITextRangeProvider { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FindText)(::windows_core::Interface::as_raw(self), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result { + pub unsafe fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAttributeValue)(::windows_core::Interface::as_raw(self), attributeid, &mut result__).from_abi(result__) } @@ -2944,15 +2849,9 @@ pub struct ITextRangeProvider_Vtbl { pub Compare: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, range: *mut ::core::ffi::c_void, pretval: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub CompareEndpoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, endpoint: TextPatternRangeEndpoint, targetrange: *mut ::core::ffi::c_void, targetendpoint: TextPatternRangeEndpoint, pretval: *mut i32) -> ::windows_core::HRESULT, pub ExpandToEnclosingUnit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unit: TextUnit) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FindAttribute: usize, + pub FindAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, backward: super::super::Foundation::BOOL, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FindText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: ::std::mem::MaybeUninit<::windows_core::BSTR>, backward: super::super::Foundation::BOOL, ignorecase: super::super::Foundation::BOOL, pretval: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttributeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, pretval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttributeValue: usize, + pub GetAttributeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attributeid: UIA_TEXTATTRIBUTE_ID, pretval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetBoundingRectangles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pretval: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -2995,14 +2894,13 @@ impl ITextRangeProvider2 { pub unsafe fn ExpandToEnclosingUnit(&self, unit: TextUnit) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ExpandToEnclosingUnit)(::windows_core::Interface::as_raw(self), unit).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: P0) -> ::windows_core::Result + pub unsafe fn FindAttribute(&self, attributeid: UIA_TEXTATTRIBUTE_ID, val: P0, backward: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FindAttribute)(::windows_core::Interface::as_raw(self), attributeid, ::core::mem::transmute(val), backward.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FindAttribute)(::windows_core::Interface::as_raw(self), attributeid, val.into_param().abi(), backward.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, text: P0, backward: P1, ignorecase: P2) -> ::windows_core::Result where @@ -3013,9 +2911,7 @@ impl ITextRangeProvider2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.FindText)(::windows_core::Interface::as_raw(self), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result { + pub unsafe fn GetAttributeValue(&self, attributeid: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetAttributeValue)(::windows_core::Interface::as_raw(self), attributeid, &mut result__).from_abi(result__) } @@ -3298,17 +3194,19 @@ impl IUIAutomation { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -3435,17 +3333,16 @@ impl IUIAutomation { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3487,11 +3384,12 @@ impl IUIAutomation { { (::windows_core::Interface::vtable(self).PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -3548,14 +3446,8 @@ pub struct IUIAutomation_Vtbl { pub CreateCacheRequest: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cacherequest: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateTrueCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateFalseCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreatePropertyCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreatePropertyCondition: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreatePropertyConditionEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CreatePropertyConditionEx: usize, + pub CreatePropertyCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + pub CreatePropertyConditionEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: PropertyConditionFlags, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub CreateAndCondition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, condition1: *mut ::core::ffi::c_void, condition2: *mut ::core::ffi::c_void, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateAndConditionFromArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, conditions: *const super::super::System::Com::SAFEARRAY, newcondition: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3590,14 +3482,8 @@ pub struct IUIAutomation_Vtbl { pub IntSafeArrayToNativeArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] IntSafeArrayToNativeArray: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RectToVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rc: super::super::Foundation::RECT, var: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RectToVariant: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub VariantToRect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT, rc: *mut super::super::Foundation::RECT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - VariantToRect: usize, + pub RectToVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rc: super::super::Foundation::RECT, var: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub VariantToRect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>, rc: *mut super::super::Foundation::RECT) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub SafeArrayToRectNativeArray: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rects: *const super::super::System::Com::SAFEARRAY, rectarray: *mut *mut super::super::Foundation::RECT, rectarraycount: *mut i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3614,10 +3500,7 @@ pub struct IUIAutomation_Vtbl { pub PollForPotentialSupportedProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pelement: *mut ::core::ffi::c_void, propertyids: *mut *mut super::super::System::Com::SAFEARRAY, propertynames: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] PollForPotentialSupportedProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CheckNotSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: super::super::System::Variant::VARIANT, isnotsupported: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CheckNotSupported: usize, + pub CheckNotSupported: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, isnotsupported: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub ReservedNotSupportedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, notsupportedvalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ReservedMixedAttributeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mixedattributevalue: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] @@ -3737,17 +3620,19 @@ impl IUIAutomation2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -3874,17 +3759,16 @@ impl IUIAutomation2 { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3926,11 +3810,12 @@ impl IUIAutomation2 { { (::windows_core::Interface::vtable(self).base__.PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -4103,17 +3988,19 @@ impl IUIAutomation3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -4240,17 +4127,16 @@ impl IUIAutomation3 { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4292,11 +4178,12 @@ impl IUIAutomation3 { { (::windows_core::Interface::vtable(self).base__.base__.PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -4480,17 +4367,19 @@ impl IUIAutomation4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -4617,17 +4506,16 @@ impl IUIAutomation4 { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4669,11 +4557,12 @@ impl IUIAutomation4 { { (::windows_core::Interface::vtable(self).base__.base__.base__.PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -4872,17 +4761,19 @@ impl IUIAutomation5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -5009,17 +4900,16 @@ impl IUIAutomation5 { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5061,11 +4951,12 @@ impl IUIAutomation5 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -5279,17 +5170,19 @@ impl IUIAutomation6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CreateFalseCondition)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CreatePropertyCondition(&self, propertyid: UIA_PROPERTY_ID, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CreatePropertyCondition)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, flags: PropertyConditionFlags) -> ::windows_core::Result { + pub unsafe fn CreatePropertyConditionEx(&self, propertyid: UIA_PROPERTY_ID, value: P0, flags: PropertyConditionFlags) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(value), flags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CreatePropertyConditionEx)(::windows_core::Interface::as_raw(self), propertyid, value.into_param().abi(), flags, &mut result__).from_abi(result__) } pub unsafe fn CreateAndCondition(&self, condition1: P0, condition2: P1) -> ::windows_core::Result where @@ -5416,17 +5309,16 @@ impl IUIAutomation6 { pub unsafe fn IntSafeArrayToNativeArray(&self, intarray: *const super::super::System::Com::SAFEARRAY, array: *mut *mut i32, arraycount: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.IntSafeArrayToNativeArray)(::windows_core::Interface::as_raw(self), intarray, array, arraycount).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result { + pub unsafe fn RectToVariant(&self, rc: super::super::Foundation::RECT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.RectToVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(rc), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn VariantToRect(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn VariantToRect(&self, var: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.VariantToRect)(::windows_core::Interface::as_raw(self), var.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -5468,11 +5360,12 @@ impl IUIAutomation6 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.PollForPotentialSupportedProperties)(::windows_core::Interface::as_raw(self), pelement.into_param().abi(), propertyids, propertynames).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CheckNotSupported(&self, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn CheckNotSupported(&self, value: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.CheckNotSupported)(::windows_core::Interface::as_raw(self), value.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn ReservedNotSupportedValue(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -5805,8 +5698,6 @@ pub struct IUIAutomationCacheRequest_Vtbl { ::windows_core::imp::com_interface!(IUIAutomationChangesEventHandler, IUIAutomationChangesEventHandler_Vtbl, 0x58edca55_2c3e_4980_b1b9_56c17f27a2a0); ::windows_core::imp::interface_hierarchy!(IUIAutomationChangesEventHandler, ::windows_core::IUnknown); impl IUIAutomationChangesEventHandler { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn HandleChangesEvent(&self, sender: P0, uiachanges: &[UiaChangeInfo]) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, @@ -5818,10 +5709,7 @@ impl IUIAutomationChangesEventHandler { #[doc(hidden)] pub struct IUIAutomationChangesEventHandler_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub HandleChangesEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, uiachanges: *const UiaChangeInfo, changescount: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - HandleChangesEvent: usize, } ::windows_core::imp::com_interface!(IUIAutomationCondition, IUIAutomationCondition_Vtbl, 0x352ffba8_0973_437c_a61f_f64cafd81df9); ::windows_core::imp::interface_hierarchy!(IUIAutomationCondition, ::windows_core::IUnknown); @@ -6015,30 +5903,22 @@ impl IUIAutomationElement { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -6349,22 +6229,10 @@ pub struct IUIAutomationElement_Vtbl { pub FindFirstBuildCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FindAllBuildCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub BuildUpdatedCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, updatedelement: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCurrentPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCurrentPropertyValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCurrentPropertyValueEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCurrentPropertyValueEx: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCachedPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCachedPropertyValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCachedPropertyValueEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCachedPropertyValueEx: usize, + pub GetCurrentPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCurrentPropertyValueEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCachedPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetCachedPropertyValueEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: super::super::Foundation::BOOL, retval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetCurrentPatternAs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, patternid: UIA_PATTERN_ID, riid: *const ::windows_core::GUID, patternobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetCachedPatternAs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, patternid: UIA_PATTERN_ID, riid: *const ::windows_core::GUID, patternobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetCurrentPattern: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, patternid: UIA_PATTERN_ID, patternobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -6486,30 +6354,22 @@ impl IUIAutomationElement2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -6890,30 +6750,22 @@ impl IUIAutomationElement3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -7302,30 +7154,22 @@ impl IUIAutomationElement4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -7771,30 +7615,22 @@ impl IUIAutomationElement5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -8244,30 +8080,22 @@ impl IUIAutomationElement6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -8723,30 +8551,22 @@ impl IUIAutomationElement7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -9179,9 +8999,7 @@ impl IUIAutomationElement7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FindAllWithOptionsBuildCache)(::windows_core::Interface::as_raw(self), scope, condition.into_param().abi(), cacherequest.into_param().abi(), traversaloptions, root.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetCurrentMetadataValue)(::windows_core::Interface::as_raw(self), targetid, metadataid, &mut result__).from_abi(result__) } @@ -9194,10 +9012,7 @@ pub struct IUIAutomationElement7_Vtbl { pub FindAllWithOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, traversaloptions: TreeTraversalOptions, root: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FindFirstWithOptionsBuildCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, traversaloptions: TreeTraversalOptions, root: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FindAllWithOptionsBuildCache: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, scope: TreeScope, condition: *mut ::core::ffi::c_void, cacherequest: *mut ::core::ffi::c_void, traversaloptions: TreeTraversalOptions, root: *mut ::core::ffi::c_void, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCurrentMetadataValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCurrentMetadataValue: usize, + pub GetCurrentMetadataValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, targetid: i32, metadataid: UIA_METADATA_ID, returnval: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUIAutomationElement8, IUIAutomationElement8_Vtbl, 0x8c60217d_5411_4cde_bcc0_1ceda223830c); ::windows_core::imp::interface_hierarchy!(IUIAutomationElement8, ::windows_core::IUnknown, IUIAutomationElement, IUIAutomationElement2, IUIAutomationElement3, IUIAutomationElement4, IUIAutomationElement5, IUIAutomationElement6, IUIAutomationElement7); @@ -9248,30 +9063,22 @@ impl IUIAutomationElement8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -9704,9 +9511,7 @@ impl IUIAutomationElement8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.FindAllWithOptionsBuildCache)(::windows_core::Interface::as_raw(self), scope, condition.into_param().abi(), cacherequest.into_param().abi(), traversaloptions, root.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetCurrentMetadataValue)(::windows_core::Interface::as_raw(self), targetid, metadataid, &mut result__).from_abi(result__) } @@ -9775,30 +9580,22 @@ impl IUIAutomationElement9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.BuildUpdatedCache)(::windows_core::Interface::as_raw(self), cacherequest.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.GetCurrentPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCurrentPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.GetCurrentPropertyValueEx)(::windows_core::Interface::as_raw(self), propertyid, ignoredefaultvalue.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result { + pub unsafe fn GetCachedPropertyValue(&self, propertyid: UIA_PROPERTY_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.GetCachedPropertyValue)(::windows_core::Interface::as_raw(self), propertyid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result + pub unsafe fn GetCachedPropertyValueEx(&self, propertyid: UIA_PROPERTY_ID, ignoredefaultvalue: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -10231,9 +10028,7 @@ impl IUIAutomationElement9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.FindAllWithOptionsBuildCache)(::windows_core::Interface::as_raw(self), scope, condition.into_param().abi(), cacherequest.into_param().abi(), traversaloptions, root.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result { + pub unsafe fn GetCurrentMetadataValue(&self, targetid: i32, metadataid: UIA_METADATA_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetCurrentMetadataValue)(::windows_core::Interface::as_raw(self), targetid, metadataid, &mut result__).from_abi(result__) } @@ -10513,24 +10308,20 @@ pub struct IUIAutomationInvokePattern_Vtbl { ::windows_core::imp::com_interface!(IUIAutomationItemContainerPattern, IUIAutomationItemContainerPattern_Vtbl, 0xc690fdb2_27a8_423c_812d_429773c9084e); ::windows_core::imp::interface_hierarchy!(IUIAutomationItemContainerPattern, ::windows_core::IUnknown); impl IUIAutomationItemContainerPattern { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindItemByProperty(&self, pstartafter: P0, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn FindItemByProperty(&self, pstartafter: P0, propertyid: UIA_PROPERTY_ID, value: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindItemByProperty)(::windows_core::Interface::as_raw(self), pstartafter.into_param().abi(), propertyid, ::core::mem::transmute(value), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindItemByProperty)(::windows_core::Interface::as_raw(self), pstartafter.into_param().abi(), propertyid, value.into_param().abi(), &mut result__).from_abi(result__) } } #[repr(C)] #[doc(hidden)] pub struct IUIAutomationItemContainerPattern_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindItemByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: super::super::System::Variant::VARIANT, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FindItemByProperty: usize, + pub FindItemByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pstartafter: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pfound: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUIAutomationLegacyIAccessiblePattern, IUIAutomationLegacyIAccessiblePattern_Vtbl, 0x828055ad_355b_4435_86d5_3b51c14a9b1b); ::windows_core::imp::interface_hierarchy!(IUIAutomationLegacyIAccessiblePattern, ::windows_core::IUnknown); @@ -10835,23 +10626,19 @@ pub struct IUIAutomationPatternInstance_Vtbl { ::windows_core::imp::com_interface!(IUIAutomationPropertyChangedEventHandler, IUIAutomationPropertyChangedEventHandler_Vtbl, 0x40cd37d4_c756_4b0c_8c6f_bddfeeb13b50); ::windows_core::imp::interface_hierarchy!(IUIAutomationPropertyChangedEventHandler, ::windows_core::IUnknown); impl IUIAutomationPropertyChangedEventHandler { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn HandlePropertyChangedEvent(&self, sender: P0, propertyid: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn HandlePropertyChangedEvent(&self, sender: P0, propertyid: UIA_PROPERTY_ID, newvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).HandlePropertyChangedEvent)(::windows_core::Interface::as_raw(self), sender.into_param().abi(), propertyid, ::core::mem::transmute(newvalue)).ok() + (::windows_core::Interface::vtable(self).HandlePropertyChangedEvent)(::windows_core::Interface::as_raw(self), sender.into_param().abi(), propertyid, newvalue.into_param().abi()).ok() } } #[repr(C)] #[doc(hidden)] pub struct IUIAutomationPropertyChangedEventHandler_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub HandlePropertyChangedEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, newvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - HandlePropertyChangedEvent: usize, + pub HandlePropertyChangedEvent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sender: *mut ::core::ffi::c_void, propertyid: UIA_PROPERTY_ID, newvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUIAutomationPropertyCondition, IUIAutomationPropertyCondition_Vtbl, 0x99ebf2cb_5578_4267_9ad4_afd6ea77e94b); ::windows_core::imp::interface_hierarchy!(IUIAutomationPropertyCondition, ::windows_core::IUnknown, IUIAutomationCondition); @@ -10860,9 +10647,7 @@ impl IUIAutomationPropertyCondition { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PropertyId)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PropertyValue(&self) -> ::windows_core::Result { + pub unsafe fn PropertyValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PropertyValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -10876,10 +10661,7 @@ impl IUIAutomationPropertyCondition { pub struct IUIAutomationPropertyCondition_Vtbl { pub base__: IUIAutomationCondition_Vtbl, pub PropertyId: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: *mut UIA_PROPERTY_ID) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PropertyValue: usize, + pub PropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PropertyConditionFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, flags: *mut PropertyConditionFlags) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IUIAutomationProxyFactory, IUIAutomationProxyFactory_Vtbl, 0x85b94ecd_849d_42b6_b94d_d6db23fdf5a4); @@ -11861,14 +11643,13 @@ impl IUIAutomationTextRange { pub unsafe fn ExpandToEnclosingUnit(&self, textunit: TextUnit) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ExpandToEnclosingUnit)(::windows_core::Interface::as_raw(self), textunit).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: P0) -> ::windows_core::Result + pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: P0, backward: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindAttribute)(::windows_core::Interface::as_raw(self), attr, ::core::mem::transmute(val), backward.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindAttribute)(::windows_core::Interface::as_raw(self), attr, val.into_param().abi(), backward.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, text: P0, backward: P1, ignorecase: P2) -> ::windows_core::Result where @@ -11879,9 +11660,7 @@ impl IUIAutomationTextRange { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FindText)(::windows_core::Interface::as_raw(self), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result { + pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAttributeValue)(::windows_core::Interface::as_raw(self), attr, &mut result__).from_abi(result__) } @@ -11941,15 +11720,9 @@ pub struct IUIAutomationTextRange_Vtbl { pub Compare: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, range: *mut ::core::ffi::c_void, aresame: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub CompareEndpoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, srcendpoint: TextPatternRangeEndpoint, range: *mut ::core::ffi::c_void, targetendpoint: TextPatternRangeEndpoint, compvalue: *mut i32) -> ::windows_core::HRESULT, pub ExpandToEnclosingUnit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, textunit: TextUnit) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: super::super::Foundation::BOOL, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - FindAttribute: usize, + pub FindAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, val: ::std::mem::MaybeUninit<::windows_core::VARIANT>, backward: super::super::Foundation::BOOL, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FindText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, text: ::std::mem::MaybeUninit<::windows_core::BSTR>, backward: super::super::Foundation::BOOL, ignorecase: super::super::Foundation::BOOL, found: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttributeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, value: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttributeValue: usize, + pub GetAttributeValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, attr: UIA_TEXTATTRIBUTE_ID, value: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetBoundingRectangles: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, boundingrects: *mut *mut super::super::System::Com::SAFEARRAY) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -11989,14 +11762,13 @@ impl IUIAutomationTextRange2 { pub unsafe fn ExpandToEnclosingUnit(&self, textunit: TextUnit) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ExpandToEnclosingUnit)(::windows_core::Interface::as_raw(self), textunit).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: P0) -> ::windows_core::Result + pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: P0, backward: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FindAttribute)(::windows_core::Interface::as_raw(self), attr, ::core::mem::transmute(val), backward.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FindAttribute)(::windows_core::Interface::as_raw(self), attr, val.into_param().abi(), backward.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, text: P0, backward: P1, ignorecase: P2) -> ::windows_core::Result where @@ -12007,9 +11779,7 @@ impl IUIAutomationTextRange2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.FindText)(::windows_core::Interface::as_raw(self), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result { + pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetAttributeValue)(::windows_core::Interface::as_raw(self), attr, &mut result__).from_abi(result__) } @@ -12094,14 +11864,13 @@ impl IUIAutomationTextRange3 { pub unsafe fn ExpandToEnclosingUnit(&self, textunit: TextUnit) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.ExpandToEnclosingUnit)(::windows_core::Interface::as_raw(self), textunit).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: super::super::System::Variant::VARIANT, backward: P0) -> ::windows_core::Result + pub unsafe fn FindAttribute(&self, attr: UIA_TEXTATTRIBUTE_ID, val: P0, backward: P1) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.FindAttribute)(::windows_core::Interface::as_raw(self), attr, ::core::mem::transmute(val), backward.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.FindAttribute)(::windows_core::Interface::as_raw(self), attr, val.into_param().abi(), backward.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, text: P0, backward: P1, ignorecase: P2) -> ::windows_core::Result where @@ -12112,9 +11881,7 @@ impl IUIAutomationTextRange3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.FindText)(::windows_core::Interface::as_raw(self), text.into_param().abi(), backward.into_param().abi(), ignorecase.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result { + pub unsafe fn GetAttributeValue(&self, attr: UIA_TEXTATTRIBUTE_ID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetAttributeValue)(::windows_core::Interface::as_raw(self), attr, &mut result__).from_abi(result__) } @@ -15837,65 +15604,62 @@ impl ::core::default::Default for UiaCacheRequest { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct UiaChangeInfo { pub uiaId: i32, - pub payload: super::super::System::Variant::VARIANT, - pub extraInfo: super::super::System::Variant::VARIANT, + pub payload: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, + pub extraInfo: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for UiaChangeInfo { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for UiaChangeInfo { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("UiaChangeInfo").field("uiaId", &self.uiaId).field("payload", &self.payload).field("extraInfo", &self.extraInfo).finish() + } +} impl ::windows_core::TypeKind for UiaChangeInfo { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for UiaChangeInfo { + fn eq(&self, other: &Self) -> bool { + self.uiaId == other.uiaId && self.payload == other.payload && self.extraInfo == other.extraInfo + } +} +impl ::core::cmp::Eq for UiaChangeInfo {} impl ::core::default::Default for UiaChangeInfo { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct UiaChangesEventArgs { pub Type: EventArgsType, pub EventId: i32, pub EventIdCount: i32, pub pUiaChanges: *mut UiaChangeInfo, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::marker::Copy for UiaChangesEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for UiaChangesEventArgs { fn clone(&self) -> Self { *self } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::fmt::Debug for UiaChangesEventArgs { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { f.debug_struct("UiaChangesEventArgs").field("Type", &self.Type).field("EventId", &self.EventId).field("EventIdCount", &self.EventIdCount).field("pUiaChanges", &self.pUiaChanges).finish() } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::TypeKind for UiaChangesEventArgs { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::PartialEq for UiaChangesEventArgs { fn eq(&self, other: &Self) -> bool { self.Type == other.Type && self.EventId == other.EventId && self.EventIdCount == other.EventIdCount && self.pUiaChanges == other.pUiaChanges } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::cmp::Eq for UiaChangesEventArgs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::default::Default for UiaChangesEventArgs { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16053,51 +15817,63 @@ impl ::core::default::Default for UiaPoint { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct UiaPropertyChangedEventArgs { pub Type: EventArgsType, pub EventId: UIA_EVENT_ID, pub PropertyId: i32, - pub OldValue: super::super::System::Variant::VARIANT, - pub NewValue: super::super::System::Variant::VARIANT, + pub OldValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, + pub NewValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for UiaPropertyChangedEventArgs { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for UiaPropertyChangedEventArgs { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("UiaPropertyChangedEventArgs").field("Type", &self.Type).field("EventId", &self.EventId).field("PropertyId", &self.PropertyId).field("OldValue", &self.OldValue).field("NewValue", &self.NewValue).finish() + } +} impl ::windows_core::TypeKind for UiaPropertyChangedEventArgs { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for UiaPropertyChangedEventArgs { + fn eq(&self, other: &Self) -> bool { + self.Type == other.Type && self.EventId == other.EventId && self.PropertyId == other.PropertyId && self.OldValue == other.OldValue && self.NewValue == other.NewValue + } +} +impl ::core::cmp::Eq for UiaPropertyChangedEventArgs {} impl ::core::default::Default for UiaPropertyChangedEventArgs { fn default() -> Self { unsafe { ::core::mem::zeroed() } } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct UiaPropertyCondition { pub ConditionType: ConditionType, pub PropertyId: UIA_PROPERTY_ID, - pub Value: super::super::System::Variant::VARIANT, + pub Value: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, pub Flags: PropertyConditionFlags, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for UiaPropertyCondition { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for UiaPropertyCondition { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("UiaPropertyCondition").field("ConditionType", &self.ConditionType).field("PropertyId", &self.PropertyId).field("Value", &self.Value).field("Flags", &self.Flags).finish() + } +} impl ::windows_core::TypeKind for UiaPropertyCondition { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for UiaPropertyCondition { + fn eq(&self, other: &Self) -> bool { + self.ConditionType == other.ConditionType && self.PropertyId == other.PropertyId && self.Value == other.Value && self.Flags == other.Flags + } +} +impl ::core::cmp::Eq for UiaPropertyCondition {} impl ::core::default::Default for UiaPropertyCondition { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -16241,12 +16017,12 @@ impl ::core::default::Default for UiaWindowClosedEventArgs { unsafe { ::core::mem::zeroed() } } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] -pub type LPFNACCESSIBLECHILDREN = ::core::option::Option, ichildstart: i32, cchildren: i32, rgvarchildren: *mut super::super::System::Variant::VARIANT, pcobtained: *mut i32) -> ::windows_core::HRESULT>; -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] -pub type LPFNACCESSIBLEOBJECTFROMPOINT = ::core::option::Option, pvarchild: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT>; +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] +pub type LPFNACCESSIBLECHILDREN = ::core::option::Option, ichildstart: i32, cchildren: i32, rgvarchildren: *mut ::windows_core::VARIANT, pcobtained: *mut i32) -> ::windows_core::HRESULT>; +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] +pub type LPFNACCESSIBLEOBJECTFROMPOINT = ::core::option::Option, pvarchild: *mut ::windows_core::VARIANT) -> ::windows_core::HRESULT>; pub type LPFNACCESSIBLEOBJECTFROMWINDOW = ::core::option::Option ::windows_core::HRESULT>; pub type LPFNCREATESTDACCESSIBLEOBJECT = ::core::option::Option ::windows_core::HRESULT>; pub type LPFNLRESULTFROMOBJECT = ::core::option::Option) -> super::super::Foundation::LRESULT>; diff --git a/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/impl.rs index 137c8bd16f..bd9d214a5d 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/impl.rs @@ -226,17 +226,13 @@ impl IRichEditOleCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IRicheditUiaOverrides_Impl: Sized { - fn GetPropertyOverrideValue(&self, propertyid: i32, pretvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn GetPropertyOverrideValue(&self, propertyid: i32, pretvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IRicheditUiaOverrides {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IRicheditUiaOverrides_Vtbl { pub const fn new, Impl: IRicheditUiaOverrides_Impl, const OFFSET: isize>() -> IRicheditUiaOverrides_Vtbl { - unsafe extern "system" fn GetPropertyOverrideValue, Impl: IRicheditUiaOverrides_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: i32, pretvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropertyOverrideValue, Impl: IRicheditUiaOverrides_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyid: i32, pretvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetPropertyOverrideValue(::core::mem::transmute_copy(&propertyid), ::core::mem::transmute_copy(&pretvalue)).into() @@ -247,12 +243,12 @@ impl IRicheditUiaOverrides_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextDisplays_Impl: Sized + super::super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextDisplays {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextDisplays_Vtbl { pub const fn new, Impl: ITextDisplays_Impl, const OFFSET: isize>() -> ITextDisplays_Vtbl { Self { base__: super::super::super::System::Com::IDispatch_Vtbl::new::() } @@ -261,8 +257,8 @@ impl ITextDisplays_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextDocument_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetName(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetSelection(&self) -> ::windows_core::Result; @@ -273,8 +269,8 @@ pub trait ITextDocument_Impl: Sized + super::super::super::System::Com::IDispatc fn GetDefaultTabStop(&self) -> ::windows_core::Result; fn SetDefaultTabStop(&self, value: f32) -> ::windows_core::Result<()>; fn New(&self) -> ::windows_core::Result<()>; - fn Open(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()>; - fn Save(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()>; + fn Open(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()>; + fn Save(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()>; fn Freeze(&self) -> ::windows_core::Result; fn Unfreeze(&self) -> ::windows_core::Result; fn BeginEditCollection(&self) -> ::windows_core::Result<()>; @@ -284,9 +280,9 @@ pub trait ITextDocument_Impl: Sized + super::super::super::System::Com::IDispatc fn Range(&self, cpactive: i32, cpanchor: i32) -> ::windows_core::Result; fn RangeFromPoint(&self, x: i32, y: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextDocument {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextDocument_Vtbl { pub const fn new, Impl: ITextDocument_Impl, const OFFSET: isize>() -> ITextDocument_Vtbl { unsafe extern "system" fn GetName, Impl: ITextDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -370,12 +366,12 @@ impl ITextDocument_Vtbl { let this = (*this).get_impl(); this.New().into() } - unsafe extern "system" fn Open, Impl: ITextDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Open, Impl: ITextDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Open(::core::mem::transmute_copy(&pvar), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&codepage)).into() } - unsafe extern "system" fn Save, Impl: ITextDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Save, Impl: ITextDocument_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Save(::core::mem::transmute_copy(&pvar), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&codepage)).into() @@ -483,8 +479,8 @@ impl ITextDocument_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextDocument2_Impl: Sized + ITextDocument_Impl { fn GetCaretType(&self) -> ::windows_core::Result; fn SetCaretType(&self, value: i32) -> ::windows_core::Result<()>; @@ -531,9 +527,9 @@ pub trait ITextDocument2_Impl: Sized + ITextDocument_Impl { fn GetNewStory(&self) -> ::windows_core::Result; fn GetStory(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextDocument2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextDocument2_Vtbl { pub const fn new, Impl: ITextDocument2_Impl, const OFFSET: isize>() -> ITextDocument2_Vtbl { unsafe extern "system" fn GetCaretType, Impl: ITextDocument2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut i32) -> ::windows_core::HRESULT { @@ -952,8 +948,8 @@ impl ITextDocument2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextDocument2Old_Impl: Sized + ITextDocument_Impl { fn AttachMsgFilter(&self, pfilter: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn SetEffectColor(&self, index: i32, cr: super::super::super::Foundation::COLORREF) -> ::windows_core::Result<()>; @@ -980,9 +976,9 @@ pub trait ITextDocument2Old_Impl: Sized + ITextDocument_Impl { fn GetCallManager(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn ReleaseCallManager(&self, pvoid: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextDocument2Old {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextDocument2Old_Vtbl { pub const fn new, Impl: ITextDocument2Old_Impl, const OFFSET: isize>() -> ITextDocument2Old_Vtbl { unsafe extern "system" fn AttachMsgFilter, Impl: ITextDocument2Old_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfilter: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1197,8 +1193,8 @@ impl ITextDocument2Old_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextFont_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetDuplicate(&self) -> ::windows_core::Result; fn SetDuplicate(&self, pfont: ::core::option::Option<&ITextFont>) -> ::windows_core::Result<()>; @@ -1256,9 +1252,9 @@ pub trait ITextFont_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn GetWeight(&self) -> ::windows_core::Result; fn SetWeight(&self, value: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextFont {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextFont_Vtbl { pub const fn new, Impl: ITextFont_Impl, const OFFSET: isize>() -> ITextFont_Vtbl { unsafe extern "system" fn GetDuplicate, Impl: ITextFont_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppfont: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1767,8 +1763,8 @@ impl ITextFont_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextFont2_Impl: Sized + ITextFont_Impl { fn GetCount(&self) -> ::windows_core::Result; fn GetAutoLigatures(&self) -> ::windows_core::Result; @@ -1817,9 +1813,9 @@ pub trait ITextFont2_Impl: Sized + ITextFont_Impl { fn SetEffects2(&self, value: i32, mask: i32) -> ::windows_core::Result<()>; fn SetProperty(&self, r#type: i32, value: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextFont2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextFont2_Vtbl { pub const fn new, Impl: ITextFont2_Impl, const OFFSET: isize>() -> ITextFont2_Vtbl { unsafe extern "system" fn GetCount, Impl: ITextFont2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT { @@ -2635,8 +2631,8 @@ impl ITextHost2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextPara_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetDuplicate(&self) -> ::windows_core::Result; fn SetDuplicate(&self, ppara: ::core::option::Option<&ITextPara>) -> ::windows_core::Result<()>; @@ -2687,9 +2683,9 @@ pub trait ITextPara_Impl: Sized + super::super::super::System::Com::IDispatch_Im fn DeleteTab(&self, tbpos: f32) -> ::windows_core::Result<()>; fn GetTab(&self, itab: i32, ptbpos: *mut f32, ptbalign: *mut i32, ptbleader: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextPara {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextPara_Vtbl { pub const fn new, Impl: ITextPara_Impl, const OFFSET: isize>() -> ITextPara_Vtbl { unsafe extern "system" fn GetDuplicate, Impl: ITextPara_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pppara: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3132,8 +3128,8 @@ impl ITextPara_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextPara2_Impl: Sized + ITextPara_Impl { fn GetBorders(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetDuplicate2(&self) -> ::windows_core::Result; @@ -3152,9 +3148,9 @@ pub trait ITextPara2_Impl: Sized + ITextPara_Impl { fn SetEffects(&self, value: i32, mask: i32) -> ::windows_core::Result<()>; fn SetProperty(&self, r#type: i32, value: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextPara2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextPara2_Vtbl { pub const fn new, Impl: ITextPara2_Impl, const OFFSET: isize>() -> ITextPara2_Vtbl { unsafe extern "system" fn GetBorders, Impl: ITextPara2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppborders: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -3309,8 +3305,8 @@ impl ITextPara2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextRange_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetText(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetText(&self, bstr: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -3343,20 +3339,20 @@ pub trait ITextRange_Impl: Sized + super::super::super::System::Com::IDispatch_I fn Move(&self, unit: i32, count: i32) -> ::windows_core::Result; fn MoveStart(&self, unit: i32, count: i32) -> ::windows_core::Result; fn MoveEnd(&self, unit: i32, count: i32) -> ::windows_core::Result; - fn MoveWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; - fn MoveStartWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; - fn MoveEndWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; - fn MoveUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; - fn MoveStartUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; - fn MoveEndUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveStartWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveEndWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveStartUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; + fn MoveEndUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result; fn FindText(&self, bstr: &::windows_core::BSTR, count: i32, flags: tomConstants) -> ::windows_core::Result; fn FindTextStart(&self, bstr: &::windows_core::BSTR, count: i32, flags: tomConstants) -> ::windows_core::Result; fn FindTextEnd(&self, bstr: &::windows_core::BSTR, count: i32, flags: tomConstants) -> ::windows_core::Result; fn Delete(&self, unit: i32, count: i32) -> ::windows_core::Result; - fn Cut(&self) -> ::windows_core::Result; - fn Copy(&self) -> ::windows_core::Result; - fn Paste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result<()>; - fn CanPaste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result; + fn Cut(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Copy(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Paste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result<()>; + fn CanPaste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result; fn CanEdit(&self) -> ::windows_core::Result; fn ChangeCase(&self, r#type: tomConstants) -> ::windows_core::Result<()>; fn GetPoint(&self, r#type: tomConstants, px: *mut i32, py: *mut i32) -> ::windows_core::Result<()>; @@ -3364,9 +3360,9 @@ pub trait ITextRange_Impl: Sized + super::super::super::System::Com::IDispatch_I fn ScrollIntoView(&self, value: i32) -> ::windows_core::Result<()>; fn GetEmbeddedObject(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextRange {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextRange_Vtbl { pub const fn new, Impl: ITextRange_Impl, const OFFSET: isize>() -> ITextRange_Vtbl { unsafe extern "system" fn GetText, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -3644,7 +3640,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveWhile(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3655,7 +3651,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveStartWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveStartWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveStartWhile(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3666,7 +3662,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveEndWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveEndWhile, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveEndWhile(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3677,7 +3673,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveUntil(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3688,7 +3684,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveStartUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveStartUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveStartUntil(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3699,7 +3695,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn MoveEndUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveEndUntil, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.MoveEndUntil(::core::mem::transmute_copy(&cset), ::core::mem::transmute_copy(&count)) { @@ -3754,7 +3750,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Cut, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Cut, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Cut() { @@ -3765,7 +3761,7 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Copy, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Copy, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Copy() { @@ -3776,12 +3772,12 @@ impl ITextRange_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Paste, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Paste, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, format: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Paste(::core::mem::transmute_copy(&pvar), ::core::mem::transmute_copy(&format)).into() } - unsafe extern "system" fn CanPaste, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, format: i32, pvalue: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn CanPaste, Impl: ITextRange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, format: i32, pvalue: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CanPaste(::core::mem::transmute_copy(&pvar), ::core::mem::transmute_copy(&format)) { @@ -3893,8 +3889,8 @@ impl ITextRange_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextRange2_Impl: Sized + ITextSelection_Impl { fn GetCch(&self) -> ::windows_core::Result; fn GetCells(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -3937,9 +3933,9 @@ pub trait ITextRange2_Impl: Sized + ITextSelection_Impl { fn GetMathFunctionType(&self, bstr: &::windows_core::BSTR) -> ::windows_core::Result; fn InsertImage(&self, width: i32, height: i32, ascent: i32, r#type: i32, bstralttext: &::windows_core::BSTR, pstream: ::core::option::Option<&super::super::super::System::Com::IStream>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextRange2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextRange2_Vtbl { pub const fn new, Impl: ITextRange2_Impl, const OFFSET: isize>() -> ITextRange2_Vtbl { unsafe extern "system" fn GetCch, Impl: ITextRange2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pcch: *mut i32) -> ::windows_core::HRESULT { @@ -4292,8 +4288,8 @@ impl ITextRange2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextRow_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn GetAlignment(&self) -> ::windows_core::Result; fn SetAlignment(&self, value: i32) -> ::windows_core::Result<()>; @@ -4342,9 +4338,9 @@ pub trait ITextRow_Impl: Sized + super::super::super::System::Com::IDispatch_Imp fn Reset(&self, value: i32) -> ::windows_core::Result<()>; fn SetProperty(&self, r#type: i32, value: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextRow {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextRow_Vtbl { pub const fn new, Impl: ITextRow_Impl, const OFFSET: isize>() -> ITextRow_Vtbl { unsafe extern "system" fn GetAlignment, Impl: ITextRow_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvalue: *mut i32) -> ::windows_core::HRESULT { @@ -4757,8 +4753,8 @@ impl ITextRow_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextSelection_Impl: Sized + ITextRange_Impl { fn GetFlags(&self) -> ::windows_core::Result; fn SetFlags(&self, flags: i32) -> ::windows_core::Result<()>; @@ -4771,9 +4767,9 @@ pub trait ITextSelection_Impl: Sized + ITextRange_Impl { fn EndKey(&self, unit: i32, extend: i32) -> ::windows_core::Result; fn TypeText(&self, bstr: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextSelection {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextSelection_Vtbl { pub const fn new, Impl: ITextSelection_Impl, const OFFSET: isize>() -> ITextSelection_Vtbl { unsafe extern "system" fn GetFlags, Impl: ITextSelection_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pflags: *mut i32) -> ::windows_core::HRESULT { @@ -4892,12 +4888,12 @@ impl ITextSelection_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextSelection2_Impl: Sized + ITextRange2_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextSelection2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextSelection2_Vtbl { pub const fn new, Impl: ITextSelection2_Impl, const OFFSET: isize>() -> ITextSelection2_Vtbl { Self { base__: ITextRange2_Vtbl::new::() } @@ -5243,16 +5239,16 @@ impl ITextStory_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStoryRanges_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; fn GetCount(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStoryRanges {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStoryRanges_Vtbl { pub const fn new, Impl: ITextStoryRanges_Impl, const OFFSET: isize>() -> ITextStoryRanges_Vtbl { unsafe extern "system" fn _NewEnum, Impl: ITextStoryRanges_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppunkenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5299,14 +5295,14 @@ impl ITextStoryRanges_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStoryRanges2_Impl: Sized + ITextStoryRanges_Impl { fn Item2(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStoryRanges2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStoryRanges2_Vtbl { pub const fn new, Impl: ITextStoryRanges2_Impl, const OFFSET: isize>() -> ITextStoryRanges2_Vtbl { unsafe extern "system" fn Item2, Impl: ITextStoryRanges2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pprange: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5326,8 +5322,8 @@ impl ITextStoryRanges2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStrings_Impl: Sized + super::super::super::System::Com::IDispatch_Impl { fn Item(&self, index: i32) -> ::windows_core::Result; fn GetCount(&self) -> ::windows_core::Result; @@ -5347,9 +5343,9 @@ pub trait ITextStrings_Impl: Sized + super::super::super::System::Com::IDispatch fn SuffixTop(&self, bstr: &::windows_core::BSTR, prange: ::core::option::Option<&ITextRange2>) -> ::windows_core::Result<()>; fn Swap(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStrings {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStrings_Vtbl { pub const fn new, Impl: ITextStrings_Impl, const OFFSET: isize>() -> ITextStrings_Vtbl { unsafe extern "system" fn Item, Impl: ITextStrings_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, pprange: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/mod.rs index 72b4c8c0f1..a644dad26f 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Controls/RichEdit/mod.rs @@ -238,20 +238,15 @@ pub struct IRichEditOleCallback_Vtbl { ::windows_core::imp::com_interface!(IRicheditUiaOverrides, IRicheditUiaOverrides_Vtbl, 0); ::windows_core::imp::interface_hierarchy!(IRicheditUiaOverrides, ::windows_core::IUnknown); impl IRicheditUiaOverrides { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyOverrideValue(&self, propertyid: i32, pretvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetPropertyOverrideValue)(::windows_core::Interface::as_raw(self), propertyid, pretvalue).ok() + pub unsafe fn GetPropertyOverrideValue(&self, propertyid: i32, pretvalue: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetPropertyOverrideValue)(::windows_core::Interface::as_raw(self), propertyid, ::core::mem::transmute(pretvalue)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IRicheditUiaOverrides_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPropertyOverrideValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: i32, pretvalue: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPropertyOverrideValue: usize, + pub GetPropertyOverrideValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyid: i32, pretvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -318,15 +313,11 @@ impl ITextDocument { pub unsafe fn New(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).New)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Open(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Save(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } pub unsafe fn Freeze(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -383,14 +374,8 @@ pub struct ITextDocument_Vtbl { pub GetDefaultTabStop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *mut f32) -> ::windows_core::HRESULT, pub SetDefaultTabStop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, value: f32) -> ::windows_core::HRESULT, pub New: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Open: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Save: usize, + pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT, + pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: tomConstants, codepage: i32) -> ::windows_core::HRESULT, pub Freeze: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, pub Unfreeze: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcount: *mut i32) -> ::windows_core::HRESULT, pub BeginEditCollection: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -454,15 +439,11 @@ impl ITextDocument2 { pub unsafe fn New(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.New)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Open(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Save(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } pub unsafe fn Freeze(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -818,15 +799,11 @@ impl ITextDocument2Old { pub unsafe fn New(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.New)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Open(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, pvar: *const super::super::super::System::Variant::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), pvar, flags, codepage).ok() + pub unsafe fn Save(&self, pvar: *const ::windows_core::VARIANT, flags: tomConstants, codepage: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), flags, codepage).ok() } pub unsafe fn Freeze(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -2968,41 +2945,29 @@ impl ITextRange { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).MoveEnd)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveStartWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveStartWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveEndWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveEndWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveStartUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveStartUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).MoveEndUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).MoveEndUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, bstr: P0, count: i32, flags: tomConstants) -> ::windows_core::Result where @@ -3029,28 +2994,20 @@ impl ITextRange { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Delete)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Cut(&self) -> ::windows_core::Result { + pub unsafe fn Cut(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Cut)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Copy(&self) -> ::windows_core::Result { + pub unsafe fn Copy(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Copy)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Paste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Paste)(::windows_core::Interface::as_raw(self), pvar, format).ok() + pub unsafe fn Paste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Paste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanPaste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result { + pub unsafe fn CanPaste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CanPaste)(::windows_core::Interface::as_raw(self), pvar, format, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CanPaste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format, &mut result__).from_abi(result__) } pub unsafe fn CanEdit(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -3139,50 +3096,20 @@ pub struct ITextRange_Vtbl { pub Move: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unit: i32, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, pub MoveStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unit: i32, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, pub MoveEnd: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unit: i32, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveWhile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveStartWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveStartWhile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveEndWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveEndWhile: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveUntil: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveStartUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveStartUntil: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveEndUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const super::super::super::System::Variant::VARIANT, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveEndUntil: usize, + pub MoveWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, + pub MoveStartWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, + pub MoveEndWhile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, + pub MoveUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, + pub MoveStartUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, + pub MoveEndUntil: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cset: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, pub FindText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstr: ::std::mem::MaybeUninit<::windows_core::BSTR>, count: i32, flags: tomConstants, plength: *mut i32) -> ::windows_core::HRESULT, pub FindTextStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstr: ::std::mem::MaybeUninit<::windows_core::BSTR>, count: i32, flags: tomConstants, plength: *mut i32) -> ::windows_core::HRESULT, pub FindTextEnd: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstr: ::std::mem::MaybeUninit<::windows_core::BSTR>, count: i32, flags: tomConstants, plength: *mut i32) -> ::windows_core::HRESULT, pub Delete: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unit: i32, count: i32, pdelta: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Cut: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Cut: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Copy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Copy: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Paste: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Paste: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CanPaste: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const super::super::super::System::Variant::VARIANT, format: i32, pvalue: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CanPaste: usize, + pub Cut: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Copy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Paste: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, format: i32) -> ::windows_core::HRESULT, + pub CanPaste: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, format: i32, pvalue: *mut i32) -> ::windows_core::HRESULT, pub CanEdit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvalue: *mut i32) -> ::windows_core::HRESULT, pub ChangeCase: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: tomConstants) -> ::windows_core::HRESULT, pub GetPoint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, r#type: tomConstants, px: *mut i32, py: *mut i32) -> ::windows_core::HRESULT, @@ -3355,41 +3282,29 @@ impl ITextRange2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.MoveEnd)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, bstr: P0, count: i32, flags: tomConstants) -> ::windows_core::Result where @@ -3416,28 +3331,20 @@ impl ITextRange2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Delete)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Cut(&self) -> ::windows_core::Result { + pub unsafe fn Cut(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Cut)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Copy(&self) -> ::windows_core::Result { + pub unsafe fn Copy(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Copy)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Paste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Paste)(::windows_core::Interface::as_raw(self), pvar, format).ok() + pub unsafe fn Paste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.Paste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanPaste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result { + pub unsafe fn CanPaste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.CanPaste)(::windows_core::Interface::as_raw(self), pvar, format, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.CanPaste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format, &mut result__).from_abi(result__) } pub unsafe fn CanEdit(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4155,41 +4062,29 @@ impl ITextSelection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.MoveEnd)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, bstr: P0, count: i32, flags: tomConstants) -> ::windows_core::Result where @@ -4216,28 +4111,20 @@ impl ITextSelection { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Delete)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Cut(&self) -> ::windows_core::Result { + pub unsafe fn Cut(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Cut)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Copy(&self) -> ::windows_core::Result { + pub unsafe fn Copy(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Copy)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Paste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Paste)(::windows_core::Interface::as_raw(self), pvar, format).ok() + pub unsafe fn Paste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Paste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanPaste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result { + pub unsafe fn CanPaste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.CanPaste)(::windows_core::Interface::as_raw(self), pvar, format, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.CanPaste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format, &mut result__).from_abi(result__) } pub unsafe fn CanEdit(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -4482,41 +4369,29 @@ impl ITextSelection2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.MoveEnd)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveStartWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndWhile(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndWhile(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveEndWhile)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveStartUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveStartUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveStartUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveEndUntil(&self, cset: *const super::super::super::System::Variant::VARIANT, count: i32) -> ::windows_core::Result { + pub unsafe fn MoveEndUntil(&self, cset: *const ::windows_core::VARIANT, count: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), cset, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.MoveEndUntil)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(cset), count, &mut result__).from_abi(result__) } pub unsafe fn FindText(&self, bstr: P0, count: i32, flags: tomConstants) -> ::windows_core::Result where @@ -4543,28 +4418,20 @@ impl ITextSelection2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Delete)(::windows_core::Interface::as_raw(self), unit, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Cut(&self) -> ::windows_core::Result { + pub unsafe fn Cut(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Cut)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Copy(&self) -> ::windows_core::Result { + pub unsafe fn Copy(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Copy)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Paste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.Paste)(::windows_core::Interface::as_raw(self), pvar, format).ok() + pub unsafe fn Paste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.base__.Paste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanPaste(&self, pvar: *const super::super::super::System::Variant::VARIANT, format: i32) -> ::windows_core::Result { + pub unsafe fn CanPaste(&self, pvar: *const ::windows_core::VARIANT, format: i32) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.CanPaste)(::windows_core::Interface::as_raw(self), pvar, format, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.CanPaste)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvar), format, &mut result__).from_abi(result__) } pub unsafe fn CanEdit(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); diff --git a/crates/libs/windows/src/Windows/Win32/UI/Ribbon/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/Ribbon/impl.rs index 16a125a1bc..da9b5e8bc4 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Ribbon/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Ribbon/impl.rs @@ -129,23 +129,23 @@ impl IUICollectionChangedEvent_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IUICommandHandler_Impl: Sized { - fn Execute(&self, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, commandexecutionproperties: ::core::option::Option<&IUISimplePropertySet>) -> ::windows_core::Result<()>; - fn UpdateProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; + fn Execute(&self, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::windows_core::PROPVARIANT, commandexecutionproperties: ::core::option::Option<&IUISimplePropertySet>) -> ::windows_core::Result<()>; + fn UpdateProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IUICommandHandler {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IUICommandHandler_Vtbl { pub const fn new, Impl: IUICommandHandler_Impl, const OFFSET: isize>() -> IUICommandHandler_Vtbl { - unsafe extern "system" fn Execute, Impl: IUICommandHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, commandexecutionproperties: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Execute, Impl: IUICommandHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, commandexecutionproperties: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Execute(::core::mem::transmute_copy(&commandid), ::core::mem::transmute_copy(&verb), ::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(¤tvalue), ::windows_core::from_raw_borrowed(&commandexecutionproperties)).into() } - unsafe extern "system" fn UpdateProperty, Impl: IUICommandHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, newvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UpdateProperty, Impl: IUICommandHandler_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, newvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.UpdateProperty(::core::mem::transmute_copy(&commandid), ::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(¤tvalue)) { @@ -217,22 +217,22 @@ impl IUIEventingManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IUIFramework_Impl: Sized { fn Initialize(&self, framewnd: super::super::Foundation::HWND, application: ::core::option::Option<&IUIApplication>) -> ::windows_core::Result<()>; fn Destroy(&self) -> ::windows_core::Result<()>; fn LoadUI(&self, instance: super::super::Foundation::HINSTANCE, resourcename: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn GetView(&self, viewid: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn GetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; - fn SetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn InvalidateUICommand(&self, commandid: u32, flags: UI_INVALIDATIONS, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<()>; fn FlushPendingInvalidations(&self) -> ::windows_core::Result<()>; fn SetModes(&self, imodes: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IUIFramework {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IUIFramework_Vtbl { pub const fn new, Impl: IUIFramework_Impl, const OFFSET: isize>() -> IUIFramework_Vtbl { unsafe extern "system" fn Initialize, Impl: IUIFramework_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, framewnd: super::super::Foundation::HWND, application: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -255,7 +255,7 @@ impl IUIFramework_Vtbl { let this = (*this).get_impl(); this.GetView(::core::mem::transmute_copy(&viewid), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn GetUICommandProperty, Impl: IUIFramework_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetUICommandProperty, Impl: IUIFramework_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetUICommandProperty(::core::mem::transmute_copy(&commandid), ::core::mem::transmute_copy(&key)) { @@ -266,7 +266,7 @@ impl IUIFramework_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetUICommandProperty, Impl: IUIFramework_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetUICommandProperty, Impl: IUIFramework_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetUICommandProperty(::core::mem::transmute_copy(&commandid), ::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&value)).into() @@ -401,17 +401,17 @@ impl IUIRibbon_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait IUISimplePropertySet_Impl: Sized { - fn GetValue(&self, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetValue(&self, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for IUISimplePropertySet {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl IUISimplePropertySet_Vtbl { pub const fn new, Impl: IUISimplePropertySet_Impl, const OFFSET: isize>() -> IUISimplePropertySet_Vtbl { - unsafe extern "system" fn GetValue, Impl: IUISimplePropertySet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IUISimplePropertySet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&key)) { diff --git a/crates/libs/windows/src/Windows/Win32/UI/Ribbon/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/Ribbon/mod.rs index 938455f463..14fe94ba77 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Ribbon/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Ribbon/mod.rs @@ -94,17 +94,17 @@ pub struct IUICollectionChangedEvent_Vtbl { ::windows_core::imp::com_interface!(IUICommandHandler, IUICommandHandler_Vtbl, 0x75ae0a2d_dc03_4c9f_8883_069660d0beb6); ::windows_core::imp::interface_hierarchy!(IUICommandHandler, ::windows_core::IUnknown); impl IUICommandHandler { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn Execute(&self, commandid: u32, verb: UI_EXECUTIONVERB, key: ::core::option::Option<*const super::Shell::PropertiesSystem::PROPERTYKEY>, currentvalue: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>, commandexecutionproperties: P0) -> ::windows_core::Result<()> + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn Execute(&self, commandid: u32, verb: UI_EXECUTIONVERB, key: ::core::option::Option<*const super::Shell::PropertiesSystem::PROPERTYKEY>, currentvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>, commandexecutionproperties: P0) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { (::windows_core::Interface::vtable(self).Execute)(::windows_core::Interface::as_raw(self), commandid, verb, ::core::mem::transmute(key.unwrap_or(::std::ptr::null())), ::core::mem::transmute(currentvalue.unwrap_or(::std::ptr::null())), commandexecutionproperties.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn UpdateProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: ::core::option::Option<*const super::super::System::Com::StructuredStorage::PROPVARIANT>) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn UpdateProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: ::core::option::Option<*const ::windows_core::PROPVARIANT>) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).UpdateProperty)(::windows_core::Interface::as_raw(self), commandid, key, ::core::mem::transmute(currentvalue.unwrap_or(::std::ptr::null())), &mut result__).from_abi(result__) } @@ -113,13 +113,13 @@ impl IUICommandHandler { #[doc(hidden)] pub struct IUICommandHandler_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub Execute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, commandexecutionproperties: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub Execute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, verb: UI_EXECUTIONVERB, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, commandexecutionproperties: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] Execute: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub UpdateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const super::super::System::Com::StructuredStorage::PROPVARIANT, newvalue: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub UpdateProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, currentvalue: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, newvalue: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] UpdateProperty: usize, } ::windows_core::imp::com_interface!(IUIContextualUI, IUIContextualUI_Vtbl, 0xeea11f37_7c46_437c_8e55_b52122b29293); @@ -187,16 +187,16 @@ impl IUIFramework { pub unsafe fn GetView(&self, viewid: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetView)(::windows_core::Interface::as_raw(self), viewid, riid, ppv).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetUICommandProperty)(::windows_core::Interface::as_raw(self), commandid, key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetUICommandProperty)(::windows_core::Interface::as_raw(self), commandid, key, value).ok() + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn SetUICommandProperty(&self, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetUICommandProperty)(::windows_core::Interface::as_raw(self), commandid, key, ::core::mem::transmute(value)).ok() } #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] @@ -218,13 +218,13 @@ pub struct IUIFramework_Vtbl { pub Destroy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub LoadUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, instance: super::super::Foundation::HINSTANCE, resourcename: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub GetView: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, viewid: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetUICommandProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetUICommandProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetUICommandProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub SetUICommandProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub SetUICommandProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] SetUICommandProperty: usize, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub InvalidateUICommand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, commandid: u32, flags: UI_INVALIDATIONS, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::HRESULT, @@ -315,9 +315,9 @@ pub struct IUIRibbon_Vtbl { ::windows_core::imp::com_interface!(IUISimplePropertySet, IUISimplePropertySet_Vtbl, 0xc205bb48_5b1c_4219_a106_15bd0a5f24e2); ::windows_core::imp::interface_hierarchy!(IUISimplePropertySet, ::windows_core::IUnknown); impl IUISimplePropertySet { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, key: *const super::Shell::PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } @@ -326,9 +326,9 @@ impl IUISimplePropertySet { #[doc(hidden)] pub struct IUISimplePropertySet_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const super::Shell::PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetValue: usize, } pub const LIBID_UIRibbon: ::windows_core::GUID = ::windows_core::GUID::from_u128(0x942f35c2_e83b_45ef_b085_ac295dd63d5b); diff --git a/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/impl.rs index 8f3ea8c2df..aa4c897fa3 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/impl.rs @@ -70,20 +70,16 @@ impl IInitializeWithStream_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait INamedPropertyStore_Impl: Sized { - fn GetNamedValue(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result; - fn SetNamedValue(&self, pszname: &::windows_core::PCWSTR, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetNamedValue(&self, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetNamedValue(&self, pszname: &::windows_core::PCWSTR, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn GetNameCount(&self) -> ::windows_core::Result; fn GetNameAt(&self, iprop: u32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for INamedPropertyStore {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl INamedPropertyStore_Vtbl { pub const fn new, Impl: INamedPropertyStore_Impl, const OFFSET: isize>() -> INamedPropertyStore_Vtbl { - unsafe extern "system" fn GetNamedValue, Impl: INamedPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetNamedValue, Impl: INamedPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetNamedValue(::core::mem::transmute(&pszname)) { @@ -94,7 +90,7 @@ impl INamedPropertyStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetNamedValue, Impl: INamedPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetNamedValue, Impl: INamedPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetNamedValue(::core::mem::transmute(&pszname), ::core::mem::transmute_copy(&propvar)).into() @@ -227,17 +223,13 @@ impl IPersistSerializedPropStorage2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyChange_Impl: Sized + IObjectWithPropertyKey_Impl { - fn ApplyToPropVariant(&self, propvarin: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; + fn ApplyToPropVariant(&self, propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyChange {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyChange_Vtbl { pub const fn new, Impl: IPropertyChange_Impl, const OFFSET: isize>() -> IPropertyChange_Vtbl { - unsafe extern "system" fn ApplyToPropVariant, Impl: IPropertyChange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvarin: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvarout: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ApplyToPropVariant, Impl: IPropertyChange_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvarin: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvarout: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ApplyToPropVariant(::core::mem::transmute_copy(&propvarin)) { @@ -322,8 +314,8 @@ impl IPropertyChangeArray_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Search_Common\"`"] +#[cfg(feature = "Win32_System_Search_Common")] pub trait IPropertyDescription_Impl: Sized { fn GetPropertyKey(&self, pkey: *mut PROPERTYKEY) -> ::windows_core::Result<()>; fn GetCanonicalName(&self) -> ::windows_core::Result<::windows_core::PWSTR>; @@ -337,19 +329,19 @@ pub trait IPropertyDescription_Impl: Sized { fn GetColumnState(&self) -> ::windows_core::Result; fn GetGroupingRange(&self) -> ::windows_core::Result; fn GetRelativeDescriptionType(&self) -> ::windows_core::Result; - fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; + fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()>; fn GetSortDescription(&self) -> ::windows_core::Result; fn GetSortDescriptionLabel(&self, fdescending: super::super::super::Foundation::BOOL) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetAggregationType(&self) -> ::windows_core::Result; fn GetConditionType(&self, pcontype: *mut PROPDESC_CONDITION_TYPE, popdefault: *mut super::super::super::System::Search::Common::CONDITION_OPERATION) -> ::windows_core::Result<()>; fn GetEnumTypeList(&self, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR>; - fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR>; + fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl ::windows_core::RuntimeName for IPropertyDescription {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl IPropertyDescription_Vtbl { pub const fn new, Impl: IPropertyDescription_Impl, const OFFSET: isize>() -> IPropertyDescription_Vtbl { unsafe extern "system" fn GetPropertyKey, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pkey: *mut PROPERTYKEY) -> ::windows_core::HRESULT { @@ -478,7 +470,7 @@ impl IPropertyDescription_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRelativeDescription, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRelativeDescription, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar1: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propvar2: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetRelativeDescription(::core::mem::transmute_copy(&propvar1), ::core::mem::transmute_copy(&propvar2), ::core::mem::transmute_copy(&ppszdesc1), ::core::mem::transmute_copy(&ppszdesc2)).into() @@ -526,12 +518,12 @@ impl IPropertyDescription_Vtbl { let this = (*this).get_impl(); this.GetEnumTypeList(::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn CoerceToCanonicalValue, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CoerceToCanonicalValue, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CoerceToCanonicalValue(::core::mem::transmute_copy(&ppropvar)).into() } - unsafe extern "system" fn FormatForDisplay, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn FormatForDisplay, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdfflags: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FormatForDisplay(::core::mem::transmute_copy(&propvar), ::core::mem::transmute_copy(&pdfflags)) { @@ -542,7 +534,7 @@ impl IPropertyDescription_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn IsValueCanonical, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsValueCanonical, Impl: IPropertyDescription_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.IsValueCanonical(::core::mem::transmute_copy(&propvar)).into() @@ -576,17 +568,17 @@ impl IPropertyDescription_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Search_Common\"`"] +#[cfg(feature = "Win32_System_Search_Common")] pub trait IPropertyDescription2_Impl: Sized + IPropertyDescription_Impl { - fn GetImageReferenceForValue(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR>; + fn GetImageReferenceForValue(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl ::windows_core::RuntimeName for IPropertyDescription2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl IPropertyDescription2_Vtbl { pub const fn new, Impl: IPropertyDescription2_Impl, const OFFSET: isize>() -> IPropertyDescription2_Vtbl { - unsafe extern "system" fn GetImageReferenceForValue, Impl: IPropertyDescription2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszimageres: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetImageReferenceForValue, Impl: IPropertyDescription2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppszimageres: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetImageReferenceForValue(::core::mem::transmute_copy(&propvar)) { @@ -606,15 +598,15 @@ impl IPropertyDescription2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Search_Common\"`"] +#[cfg(feature = "Win32_System_Search_Common")] pub trait IPropertyDescriptionAliasInfo_Impl: Sized + IPropertyDescription_Impl { fn GetSortByAlias(&self, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetAdditionalSortByAliases(&self, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl ::windows_core::RuntimeName for IPropertyDescriptionAliasInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl IPropertyDescriptionAliasInfo_Vtbl { pub const fn new, Impl: IPropertyDescriptionAliasInfo_Impl, const OFFSET: isize>() -> IPropertyDescriptionAliasInfo_Vtbl { unsafe extern "system" fn GetSortByAlias, Impl: IPropertyDescriptionAliasInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -670,14 +662,14 @@ impl IPropertyDescriptionList_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Search_Common\"`"] +#[cfg(feature = "Win32_System_Search_Common")] pub trait IPropertyDescriptionRelatedPropertyInfo_Impl: Sized + IPropertyDescription_Impl { fn GetRelatedProperty(&self, pszrelationshipname: &::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl ::windows_core::RuntimeName for IPropertyDescriptionRelatedPropertyInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl IPropertyDescriptionRelatedPropertyInfo_Vtbl { pub const fn new, Impl: IPropertyDescriptionRelatedPropertyInfo_Impl, const OFFSET: isize>() -> IPropertyDescriptionRelatedPropertyInfo_Vtbl { unsafe extern "system" fn GetRelatedProperty, Impl: IPropertyDescriptionRelatedPropertyInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszrelationshipname: ::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -691,17 +683,17 @@ impl IPropertyDescriptionRelatedPropertyInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Search_Common\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Search_Common\"`"] +#[cfg(feature = "Win32_System_Search_Common")] pub trait IPropertyDescriptionSearchInfo_Impl: Sized + IPropertyDescription_Impl { fn GetSearchInfoFlags(&self) -> ::windows_core::Result; fn GetColumnIndexType(&self) -> ::windows_core::Result; fn GetProjectionString(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetMaxSize(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl ::windows_core::RuntimeName for IPropertyDescriptionSearchInfo {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Search_Common", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Search_Common")] impl IPropertyDescriptionSearchInfo_Vtbl { pub const fn new, Impl: IPropertyDescriptionSearchInfo_Impl, const OFFSET: isize>() -> IPropertyDescriptionSearchInfo_Vtbl { unsafe extern "system" fn GetSearchInfoFlags, Impl: IPropertyDescriptionSearchInfo_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppdsiflags: *mut PROPDESC_SEARCHINFO_FLAGS) -> ::windows_core::HRESULT { @@ -760,18 +752,14 @@ impl IPropertyDescriptionSearchInfo_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyEnumType_Impl: Sized { fn GetEnumType(&self) -> ::windows_core::Result; - fn GetValue(&self) -> ::windows_core::Result; - fn GetRangeMinValue(&self) -> ::windows_core::Result; - fn GetRangeSetValue(&self) -> ::windows_core::Result; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn GetRangeMinValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn GetRangeSetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetDisplayText(&self) -> ::windows_core::Result<::windows_core::PWSTR>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyEnumType {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyEnumType_Vtbl { pub const fn new, Impl: IPropertyEnumType_Impl, const OFFSET: isize>() -> IPropertyEnumType_Vtbl { unsafe extern "system" fn GetEnumType, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, penumtype: *mut PROPENUMTYPE) -> ::windows_core::HRESULT { @@ -785,7 +773,7 @@ impl IPropertyEnumType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -796,7 +784,7 @@ impl IPropertyEnumType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRangeMinValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarmin: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRangeMinValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarmin: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRangeMinValue() { @@ -807,7 +795,7 @@ impl IPropertyEnumType_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRangeSetValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarset: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRangeSetValue, Impl: IPropertyEnumType_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppropvarset: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRangeSetValue() { @@ -842,14 +830,10 @@ impl IPropertyEnumType_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyEnumType2_Impl: Sized + IPropertyEnumType_Impl { fn GetImageReference(&self) -> ::windows_core::Result<::windows_core::PWSTR>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyEnumType2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyEnumType2_Vtbl { pub const fn new, Impl: IPropertyEnumType2_Impl, const OFFSET: isize>() -> IPropertyEnumType2_Vtbl { unsafe extern "system" fn GetImageReference, Impl: IPropertyEnumType2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppszimageres: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -869,17 +853,13 @@ impl IPropertyEnumType2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyEnumTypeList_Impl: Sized { fn GetCount(&self) -> ::windows_core::Result; fn GetAt(&self, itype: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetConditionAt(&self, nindex: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn FindMatchingIndex(&self, propvarcmp: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result; + fn FindMatchingIndex(&self, propvarcmp: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyEnumTypeList {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyEnumTypeList_Vtbl { pub const fn new, Impl: IPropertyEnumTypeList_Impl, const OFFSET: isize>() -> IPropertyEnumTypeList_Vtbl { unsafe extern "system" fn GetCount, Impl: IPropertyEnumTypeList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pctypes: *mut u32) -> ::windows_core::HRESULT { @@ -903,7 +883,7 @@ impl IPropertyEnumTypeList_Vtbl { let this = (*this).get_impl(); this.GetConditionAt(::core::mem::transmute_copy(&nindex), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn FindMatchingIndex, Impl: IPropertyEnumTypeList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvarcmp: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pnindex: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindMatchingIndex, Impl: IPropertyEnumTypeList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propvarcmp: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pnindex: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindMatchingIndex(::core::mem::transmute_copy(&propvarcmp)) { @@ -926,18 +906,14 @@ impl IPropertyEnumTypeList_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyStore_Impl: Sized { fn GetCount(&self) -> ::windows_core::Result; fn GetAt(&self, iprop: u32, pkey: *mut PROPERTYKEY) -> ::windows_core::Result<()>; - fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result; - fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; + fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn Commit(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyStore {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyStore_Vtbl { pub const fn new, Impl: IPropertyStore_Impl, const OFFSET: isize>() -> IPropertyStore_Vtbl { unsafe extern "system" fn GetCount, Impl: IPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cprops: *mut u32) -> ::windows_core::HRESULT { @@ -956,7 +932,7 @@ impl IPropertyStore_Vtbl { let this = (*this).get_impl(); this.GetAt(::core::mem::transmute_copy(&iprop), ::core::mem::transmute_copy(&pkey)).into() } - unsafe extern "system" fn GetValue, Impl: IPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pv: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: IPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&key)) { @@ -967,7 +943,7 @@ impl IPropertyStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetValue, Impl: IPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: IPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&propvar)).into() @@ -990,17 +966,13 @@ impl IPropertyStore_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyStoreCache_Impl: Sized + IPropertyStore_Impl { fn GetState(&self, key: *const PROPERTYKEY) -> ::windows_core::Result; - fn GetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::Result<()>; + fn GetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::Result<()>; fn SetState(&self, key: *const PROPERTYKEY, state: PSC_STATE) -> ::windows_core::Result<()>; - fn SetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, state: PSC_STATE) -> ::windows_core::Result<()>; + fn SetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *const ::windows_core::PROPVARIANT, state: PSC_STATE) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyStoreCache {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyStoreCache_Vtbl { pub const fn new, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>() -> IPropertyStoreCache_Vtbl { unsafe extern "system" fn GetState, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT { @@ -1014,7 +986,7 @@ impl IPropertyStoreCache_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValueAndState, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValueAndState, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.GetValueAndState(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&pstate)).into() @@ -1024,7 +996,7 @@ impl IPropertyStoreCache_Vtbl { let this = (*this).get_impl(); this.SetState(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&state)).into() } - unsafe extern "system" fn SetValueAndState, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, state: PSC_STATE) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValueAndState, Impl: IPropertyStoreCache_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, state: PSC_STATE) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValueAndState(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&state)).into() @@ -1085,22 +1057,18 @@ impl IPropertyStoreFactory_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertySystem_Impl: Sized { fn GetPropertyDescription(&self, propkey: *const PROPERTYKEY, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetPropertyDescriptionByName(&self, pszcanonicalname: &::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetPropertyDescriptionListFromString(&self, pszproplist: &::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn EnumeratePropertyDescriptions(&self, filteron: PROPDESC_ENUMFILTER, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; - fn FormatForDisplay(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; - fn FormatForDisplayAlloc(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR>; + fn FormatForDisplay(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; + fn FormatForDisplayAlloc(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR>; fn RegisterPropertySchema(&self, pszpath: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn UnregisterPropertySchema(&self, pszpath: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn RefreshPropertySchema(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertySystem {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertySystem_Vtbl { pub const fn new, Impl: IPropertySystem_Impl, const OFFSET: isize>() -> IPropertySystem_Vtbl { unsafe extern "system" fn GetPropertyDescription, Impl: IPropertySystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propkey: *const PROPERTYKEY, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1123,12 +1091,12 @@ impl IPropertySystem_Vtbl { let this = (*this).get_impl(); this.EnumeratePropertyDescriptions(::core::mem::transmute_copy(&filteron), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&ppv)).into() } - unsafe extern "system" fn FormatForDisplay, Impl: IPropertySystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn FormatForDisplay, Impl: IPropertySystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.FormatForDisplay(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&propvar), ::core::mem::transmute_copy(&pdff), ::core::mem::transmute_copy(&psztext), ::core::mem::transmute_copy(&cchtext)).into() } - unsafe extern "system" fn FormatForDisplayAlloc, Impl: IPropertySystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { + unsafe extern "system" fn FormatForDisplayAlloc, Impl: IPropertySystem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdff: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FormatForDisplayAlloc(::core::mem::transmute_copy(&key), ::core::mem::transmute_copy(&propvar), ::core::mem::transmute_copy(&pdff)) { @@ -1188,8 +1156,6 @@ impl IPropertySystemChangeNotify_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait IPropertyUI_Impl: Sized { fn ParsePropertyName(&self, pszname: &::windows_core::PCWSTR, pfmtid: *mut ::windows_core::GUID, ppid: *mut u32, pcheaten: *mut u32) -> ::windows_core::Result<()>; fn GetCannonicalName(&self, fmtid: *const ::windows_core::GUID, pid: u32, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; @@ -1197,12 +1163,10 @@ pub trait IPropertyUI_Impl: Sized { fn GetPropertyDescription(&self, fmtid: *const ::windows_core::GUID, pid: u32, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; fn GetDefaultWidth(&self, fmtid: *const ::windows_core::GUID, pid: u32) -> ::windows_core::Result; fn GetFlags(&self, fmtid: *const ::windows_core::GUID, pid: u32) -> ::windows_core::Result; - fn FormatForDisplay(&self, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; + fn FormatForDisplay(&self, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const ::windows_core::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::Result<()>; fn GetHelpInfo(&self, fmtid: *const ::windows_core::GUID, pid: u32, pwszhelpfile: ::windows_core::PWSTR, cch: u32, puhelpid: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IPropertyUI {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl IPropertyUI_Vtbl { pub const fn new, Impl: IPropertyUI_Impl, const OFFSET: isize>() -> IPropertyUI_Vtbl { unsafe extern "system" fn ParsePropertyName, Impl: IPropertyUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, pfmtid: *mut ::windows_core::GUID, ppid: *mut u32, pcheaten: *mut u32) -> ::windows_core::HRESULT { @@ -1247,7 +1211,7 @@ impl IPropertyUI_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn FormatForDisplay, Impl: IPropertyUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn FormatForDisplay, Impl: IPropertyUI_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.FormatForDisplay(::core::mem::transmute_copy(&fmtid), ::core::mem::transmute_copy(&pid), ::core::mem::transmute_copy(&ppropvar), ::core::mem::transmute_copy(&puiff), ::core::mem::transmute_copy(&pwsztext), ::core::mem::transmute_copy(&cchtext)).into() diff --git a/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/mod.rs index bf47daa74c..f9d3666fda 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Shell/PropertiesSystem/mod.rs @@ -1,9 +1,7 @@ -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSCoerceToCanonicalValue(key: *const PROPERTYKEY, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PSCoerceToCanonicalValue(key : *const PROPERTYKEY, ppropvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - PSCoerceToCanonicalValue(key, ppropvar).ok() +pub unsafe fn PSCoerceToCanonicalValue(key: *const PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PSCoerceToCanonicalValue(key : *const PROPERTYKEY, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + PSCoerceToCanonicalValue(key, ::core::mem::transmute(ppropvar)).ok() } #[inline] pub unsafe fn PSCreateAdapterFromPropertyStore(pps: P0, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> @@ -31,11 +29,9 @@ pub unsafe fn PSCreateMultiplexPropertyStore(prgpunkstores: &[::core::option::Op ::windows_targets::link!("propsys.dll" "system" fn PSCreateMultiplexPropertyStore(prgpunkstores : *const * mut::core::ffi::c_void, cstores : u32, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSCreateMultiplexPropertyStore(::core::mem::transmute(prgpunkstores.as_ptr()), prgpunkstores.len().try_into().unwrap(), riid, ppv).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSCreatePropertyChangeArray(rgpropkey: ::core::option::Option<*const PROPERTYKEY>, rgflags: ::core::option::Option<*const PKA_FLAGS>, rgpropvar: ::core::option::Option<*const super::super::super::System::Com::StructuredStorage::PROPVARIANT>, cchanges: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PSCreatePropertyChangeArray(rgpropkey : *const PROPERTYKEY, rgflags : *const PKA_FLAGS, rgpropvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT, cchanges : u32, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); +pub unsafe fn PSCreatePropertyChangeArray(rgpropkey: ::core::option::Option<*const PROPERTYKEY>, rgflags: ::core::option::Option<*const PKA_FLAGS>, rgpropvar: ::core::option::Option<*const ::windows_core::PROPVARIANT>, cchanges: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PSCreatePropertyChangeArray(rgpropkey : *const PROPERTYKEY, rgflags : *const PKA_FLAGS, rgpropvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, cchanges : u32, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSCreatePropertyChangeArray(::core::mem::transmute(rgpropkey.unwrap_or(::std::ptr::null())), ::core::mem::transmute(rgflags.unwrap_or(::std::ptr::null())), ::core::mem::transmute(rgpropvar.unwrap_or(::std::ptr::null())), cchanges, riid, ppv).ok() } #[inline] @@ -56,32 +52,26 @@ where ::windows_targets::link!("propsys.dll" "system" fn PSCreatePropertyStoreFromPropertySetStorage(ppss : * mut::core::ffi::c_void, grfmode : u32, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSCreatePropertyStoreFromPropertySetStorage(ppss.into_param().abi(), grfmode, riid, ppv).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSCreateSimplePropertyChange(flags: PKA_FLAGS, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PSCreateSimplePropertyChange(flags : PKA_FLAGS, key : *const PROPERTYKEY, propvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); - PSCreateSimplePropertyChange(flags, key, propvar, riid, ppv).ok() +pub unsafe fn PSCreateSimplePropertyChange(flags: PKA_FLAGS, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PSCreateSimplePropertyChange(flags : PKA_FLAGS, key : *const PROPERTYKEY, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); + PSCreateSimplePropertyChange(flags, key, ::core::mem::transmute(propvar), riid, ppv).ok() } #[inline] pub unsafe fn PSEnumeratePropertyDescriptions(filteron: PROPDESC_ENUMFILTER, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> { ::windows_targets::link!("propsys.dll" "system" fn PSEnumeratePropertyDescriptions(filteron : PROPDESC_ENUMFILTER, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSEnumeratePropertyDescriptions(filteron, riid, ppv).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSFormatForDisplay(propkey: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS, pwsztext: &mut [u16]) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PSFormatForDisplay(propkey : *const PROPERTYKEY, propvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT, pdfflags : PROPDESC_FORMAT_FLAGS, pwsztext : ::windows_core::PWSTR, cchtext : u32) -> ::windows_core::HRESULT); - PSFormatForDisplay(propkey, propvar, pdfflags, ::core::mem::transmute(pwsztext.as_ptr()), pwsztext.len().try_into().unwrap()).ok() +pub unsafe fn PSFormatForDisplay(propkey: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS, pwsztext: &mut [u16]) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PSFormatForDisplay(propkey : *const PROPERTYKEY, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pdfflags : PROPDESC_FORMAT_FLAGS, pwsztext : ::windows_core::PWSTR, cchtext : u32) -> ::windows_core::HRESULT); + PSFormatForDisplay(propkey, ::core::mem::transmute(propvar), pdfflags, ::core::mem::transmute(pwsztext.as_ptr()), pwsztext.len().try_into().unwrap()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSFormatForDisplayAlloc(key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn PSFormatForDisplayAlloc(key : *const PROPERTYKEY, propvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT, pdff : PROPDESC_FORMAT_FLAGS, ppszdisplay : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn PSFormatForDisplayAlloc(key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn PSFormatForDisplayAlloc(key : *const PROPERTYKEY, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pdff : PROPDESC_FORMAT_FLAGS, ppszdisplay : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PSFormatForDisplayAlloc(key, propvar, pdff, &mut result__).from_abi(result__) + PSFormatForDisplayAlloc(key, ::core::mem::transmute(propvar), pdff, &mut result__).from_abi(result__) } #[inline] pub unsafe fn PSFormatPropertyValue(pps: P0, ppd: P1, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> @@ -93,13 +83,11 @@ where let mut result__ = ::std::mem::zeroed(); PSFormatPropertyValue(pps.into_param().abi(), ppd.into_param().abi(), pdff, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSGetImageReferenceForValue(propkey: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { - ::windows_targets::link!("propsys.dll" "system" fn PSGetImageReferenceForValue(propkey : *const PROPERTYKEY, propvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT, ppszimageres : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); +pub unsafe fn PSGetImageReferenceForValue(propkey: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { + ::windows_targets::link!("propsys.dll" "system" fn PSGetImageReferenceForValue(propkey : *const PROPERTYKEY, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, ppszimageres : *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); - PSGetImageReferenceForValue(propkey, propvar, &mut result__).from_abi(result__) + PSGetImageReferenceForValue(propkey, ::core::mem::transmute(propvar), &mut result__).from_abi(result__) } #[inline] pub unsafe fn PSGetItemPropertyHandler(punkitem: P0, freadwrite: P1, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()> @@ -126,15 +114,13 @@ pub unsafe fn PSGetNameFromPropertyKey(propkey: *const PROPERTYKEY) -> ::windows let mut result__ = ::std::mem::zeroed(); PSGetNameFromPropertyKey(propkey, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSGetNamedPropertyFromPropertyStorage(psps: P0, cb: u32, pszname: P1) -> ::windows_core::Result +pub unsafe fn PSGetNamedPropertyFromPropertyStorage(psps: P0, cb: u32, pszname: P1) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("propsys.dll" "system" fn PSGetNamedPropertyFromPropertyStorage(psps : PCUSERIALIZEDPROPSTORAGE, cb : u32, pszname : ::windows_core::PCWSTR, ppropvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn PSGetNamedPropertyFromPropertyStorage(psps : PCUSERIALIZEDPROPSTORAGE, cb : u32, pszname : ::windows_core::PCWSTR, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); PSGetNamedPropertyFromPropertyStorage(psps.into_param().abi(), cb, pszname.into_param().abi(), &mut result__).from_abi(result__) } @@ -159,14 +145,12 @@ where ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertyDescriptionListFromString(pszproplist : ::windows_core::PCWSTR, riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSGetPropertyDescriptionListFromString(pszproplist.into_param().abi(), riid, ppv).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSGetPropertyFromPropertyStorage(psps: P0, cb: u32, rpkey: *const PROPERTYKEY) -> ::windows_core::Result +pub unsafe fn PSGetPropertyFromPropertyStorage(psps: P0, cb: u32, rpkey: *const PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertyFromPropertyStorage(psps : PCUSERIALIZEDPROPSTORAGE, cb : u32, rpkey : *const PROPERTYKEY, ppropvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertyFromPropertyStorage(psps : PCUSERIALIZEDPROPSTORAGE, cb : u32, rpkey : *const PROPERTYKEY, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); PSGetPropertyFromPropertyStorage(psps.into_param().abi(), cb, rpkey, &mut result__).from_abi(result__) } @@ -183,15 +167,13 @@ pub unsafe fn PSGetPropertySystem(riid: *const ::windows_core::GUID, ppv: *mut * ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertySystem(riid : *const ::windows_core::GUID, ppv : *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT); PSGetPropertySystem(riid, ppv).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSGetPropertyValue(pps: P0, ppd: P1) -> ::windows_core::Result +pub unsafe fn PSGetPropertyValue(pps: P0, ppd: P1) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertyValue(pps : * mut::core::ffi::c_void, ppd : * mut::core::ffi::c_void, ppropvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("propsys.dll" "system" fn PSGetPropertyValue(pps : * mut::core::ffi::c_void, ppd : * mut::core::ffi::c_void, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); PSGetPropertyValue(pps.into_param().abi(), ppd.into_param().abi(), &mut result__).from_abi(result__) } @@ -381,16 +363,16 @@ where let mut result__ = ::std::mem::zeroed(); PSPropertyBag_ReadStream(propbag.into_param().abi(), propname.into_param().abi(), &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] +#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSPropertyBag_ReadType(propbag: P0, propname: P1, var: *mut super::super::super::System::Variant::VARIANT, r#type: super::super::super::System::Variant::VARENUM) -> ::windows_core::Result<()> +pub unsafe fn PSPropertyBag_ReadType(propbag: P0, propname: P1, var: *mut ::windows_core::VARIANT, r#type: super::super::super::System::Variant::VARENUM) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - ::windows_targets::link!("propsys.dll" "system" fn PSPropertyBag_ReadType(propbag : * mut::core::ffi::c_void, propname : ::windows_core::PCWSTR, var : *mut super::super::super::System::Variant:: VARIANT, r#type : super::super::super::System::Variant:: VARENUM) -> ::windows_core::HRESULT); - PSPropertyBag_ReadType(propbag.into_param().abi(), propname.into_param().abi(), var, r#type).ok() + ::windows_targets::link!("propsys.dll" "system" fn PSPropertyBag_ReadType(propbag : * mut::core::ffi::c_void, propname : ::windows_core::PCWSTR, var : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, r#type : super::super::super::System::Variant:: VARENUM) -> ::windows_core::HRESULT); + PSPropertyBag_ReadType(propbag.into_param().abi(), propname.into_param().abi(), ::core::mem::transmute(var), r#type).ok() } #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] #[cfg(feature = "Win32_System_Com_StructuredStorage")] @@ -606,16 +588,14 @@ where ::windows_targets::link!("propsys.dll" "system" fn PSRegisterPropertySchema(pszpath : ::windows_core::PCWSTR) -> ::windows_core::HRESULT); PSRegisterPropertySchema(pszpath.into_param().abi()).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] #[inline] -pub unsafe fn PSSetPropertyValue(pps: P0, ppd: P1, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> +pub unsafe fn PSSetPropertyValue(pps: P0, ppd: P1, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { - ::windows_targets::link!("propsys.dll" "system" fn PSSetPropertyValue(pps : * mut::core::ffi::c_void, ppd : * mut::core::ffi::c_void, propvar : *const super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - PSSetPropertyValue(pps.into_param().abi(), ppd.into_param().abi(), propvar).ok() + ::windows_targets::link!("propsys.dll" "system" fn PSSetPropertyValue(pps : * mut::core::ffi::c_void, ppd : * mut::core::ffi::c_void, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + PSSetPropertyValue(pps.into_param().abi(), ppd.into_param().abi(), ::core::mem::transmute(propvar)).ok() } #[inline] pub unsafe fn PSStringFromPropertyKey(pkey: *const PROPERTYKEY, psz: &mut [u16]) -> ::windows_core::Result<()> { @@ -714,25 +694,25 @@ where ::windows_targets::link!("shell32.dll" "system" fn SHPropStgCreate(psstg : * mut::core::ffi::c_void, fmtid : *const ::windows_core::GUID, pclsid : *const ::windows_core::GUID, grfflags : u32, grfmode : u32, dwdisposition : u32, ppstg : *mut * mut::core::ffi::c_void, pucodepage : *mut u32) -> ::windows_core::HRESULT); SHPropStgCreate(psstg.into_param().abi(), fmtid, ::core::mem::transmute(pclsid.unwrap_or(::std::ptr::null())), grfflags, grfmode, dwdisposition, ::core::mem::transmute(ppstg), ::core::mem::transmute(pucodepage.unwrap_or(::std::ptr::null_mut()))).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] #[inline] -pub unsafe fn SHPropStgReadMultiple(pps: P0, ucodepage: u32, cpspec: u32, rgpspec: *const super::super::super::System::Com::StructuredStorage::PROPSPEC, rgvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> +pub unsafe fn SHPropStgReadMultiple(pps: P0, ucodepage: u32, cpspec: u32, rgpspec: *const super::super::super::System::Com::StructuredStorage::PROPSPEC, rgvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("shell32.dll" "system" fn SHPropStgReadMultiple(pps : * mut::core::ffi::c_void, ucodepage : u32, cpspec : u32, rgpspec : *const super::super::super::System::Com::StructuredStorage:: PROPSPEC, rgvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - SHPropStgReadMultiple(pps.into_param().abi(), ucodepage, cpspec, rgpspec, rgvar).ok() + ::windows_targets::link!("shell32.dll" "system" fn SHPropStgReadMultiple(pps : * mut::core::ffi::c_void, ucodepage : u32, cpspec : u32, rgpspec : *const super::super::super::System::Com::StructuredStorage:: PROPSPEC, rgvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + SHPropStgReadMultiple(pps.into_param().abi(), ucodepage, cpspec, rgpspec, ::core::mem::transmute(rgvar)).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`"] +#[cfg(feature = "Win32_System_Com_StructuredStorage")] #[inline] -pub unsafe fn SHPropStgWriteMultiple(pps: P0, pucodepage: ::core::option::Option<*mut u32>, cpspec: u32, rgpspec: *const super::super::super::System::Com::StructuredStorage::PROPSPEC, rgvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> +pub unsafe fn SHPropStgWriteMultiple(pps: P0, pucodepage: ::core::option::Option<*mut u32>, cpspec: u32, rgpspec: *const super::super::super::System::Com::StructuredStorage::PROPSPEC, rgvar: *mut ::windows_core::PROPVARIANT, propidnamefirst: u32) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("shell32.dll" "system" fn SHPropStgWriteMultiple(pps : * mut::core::ffi::c_void, pucodepage : *mut u32, cpspec : u32, rgpspec : *const super::super::super::System::Com::StructuredStorage:: PROPSPEC, rgvar : *mut super::super::super::System::Com::StructuredStorage:: PROPVARIANT, propidnamefirst : u32) -> ::windows_core::HRESULT); - SHPropStgWriteMultiple(pps.into_param().abi(), ::core::mem::transmute(pucodepage.unwrap_or(::std::ptr::null_mut())), cpspec, rgpspec, rgvar, propidnamefirst).ok() + ::windows_targets::link!("shell32.dll" "system" fn SHPropStgWriteMultiple(pps : * mut::core::ffi::c_void, pucodepage : *mut u32, cpspec : u32, rgpspec : *const super::super::super::System::Com::StructuredStorage:: PROPSPEC, rgvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, propidnamefirst : u32) -> ::windows_core::HRESULT); + SHPropStgWriteMultiple(pps.into_param().abi(), ::core::mem::transmute(pucodepage.unwrap_or(::std::ptr::null_mut())), cpspec, rgpspec, ::core::mem::transmute(rgvar), propidnamefirst).ok() } ::windows_core::imp::com_interface!(ICreateObject, ICreateObject_Vtbl, 0x75121952_e0d0_43e5_9380_1d80483acf72); ::windows_core::imp::interface_hierarchy!(ICreateObject, ::windows_core::IUnknown); @@ -824,22 +804,18 @@ pub struct IInitializeWithStream_Vtbl { ::windows_core::imp::com_interface!(INamedPropertyStore, INamedPropertyStore_Vtbl, 0x71604b0f_97b0_4764_8577_2f13e98a1422); ::windows_core::imp::interface_hierarchy!(INamedPropertyStore, ::windows_core::IUnknown); impl INamedPropertyStore { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetNamedValue(&self, pszname: P0) -> ::windows_core::Result + pub unsafe fn GetNamedValue(&self, pszname: P0) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetNamedValue)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetNamedValue(&self, pszname: P0, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetNamedValue(&self, pszname: P0, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).SetNamedValue)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), propvar).ok() + (::windows_core::Interface::vtable(self).SetNamedValue)(::windows_core::Interface::as_raw(self), pszname.into_param().abi(), ::core::mem::transmute(propvar)).ok() } pub unsafe fn GetNameCount(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -854,14 +830,8 @@ impl INamedPropertyStore { #[doc(hidden)] pub struct INamedPropertyStore_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetNamedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetNamedValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetNamedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetNamedValue: usize, + pub GetNamedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetNamedValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszname: ::windows_core::PCWSTR, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetNameCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwcount: *mut u32) -> ::windows_core::HRESULT, pub GetNameAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iprop: u32, pbstrname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -945,21 +915,16 @@ impl IPropertyChange { pub unsafe fn GetPropertyKey(&self, pkey: *mut PROPERTYKEY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetPropertyKey)(::windows_core::Interface::as_raw(self), pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn ApplyToPropVariant(&self, propvarin: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn ApplyToPropVariant(&self, propvarin: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ApplyToPropVariant)(::windows_core::Interface::as_raw(self), propvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ApplyToPropVariant)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvarin), &mut result__).from_abi(result__) } } #[repr(C)] #[doc(hidden)] pub struct IPropertyChange_Vtbl { pub base__: IObjectWithPropertyKey_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub ApplyToPropVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvarin: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppropvarout: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - ApplyToPropVariant: usize, + pub ApplyToPropVariant: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvarin: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppropvarout: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyChangeArray, IPropertyChangeArray_Vtbl, 0x380f5cad_1b5e_42f2_805d_637fd392d31e); ::windows_core::imp::interface_hierarchy!(IPropertyChangeArray, ::windows_core::IUnknown); @@ -1062,10 +1027,8 @@ impl IPropertyDescription { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRelativeDescriptionType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetRelativeDescription)(::windows_core::Interface::as_raw(self), propvar1, propvar2, ppszdesc1, ppszdesc2).ok() + pub unsafe fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetRelativeDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), ppszdesc1, ppszdesc2).ok() } pub unsafe fn GetSortDescription(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1094,21 +1057,15 @@ impl IPropertyDescription { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).GetEnumTypeList)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ppropvar).ok() + pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), propvar, pdfflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), pdfflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).IsValueCanonical)(::windows_core::Interface::as_raw(self), propvar).ok() + pub unsafe fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).IsValueCanonical)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar)).ok() } } #[repr(C)] @@ -1127,10 +1084,7 @@ pub struct IPropertyDescription_Vtbl { pub GetColumnState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcsflags: *mut u32) -> ::windows_core::HRESULT, pub GetGroupingRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pgr: *mut PROPDESC_GROUPING_RANGE) -> ::windows_core::HRESULT, pub GetRelativeDescriptionType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prdt: *mut PROPDESC_RELATIVEDESCRIPTION_TYPE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetRelativeDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetRelativeDescription: usize, + pub GetRelativeDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar1: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, propvar2: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GetSortDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psd: *mut PROPDESC_SORTDESCRIPTION) -> ::windows_core::HRESULT, pub GetSortDescriptionLabel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fdescending: super::super::super::Foundation::BOOL, ppszdescription: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub GetAggregationType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, paggtype: *mut PROPDESC_AGGREGATION_TYPE) -> ::windows_core::HRESULT, @@ -1139,18 +1093,9 @@ pub struct IPropertyDescription_Vtbl { #[cfg(not(feature = "Win32_System_Search_Common"))] GetConditionType: usize, pub GetEnumTypeList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub CoerceToCanonicalValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - CoerceToCanonicalValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - FormatForDisplay: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub IsValueCanonical: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - IsValueCanonical: usize, + pub CoerceToCanonicalValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdfflags: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, + pub IsValueCanonical: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyDescription2, IPropertyDescription2_Vtbl, 0x57d2eded_5062_400e_b107_5dae79fe57a6); ::windows_core::imp::interface_hierarchy!(IPropertyDescription2, ::windows_core::IUnknown, IPropertyDescription); @@ -1202,10 +1147,8 @@ impl IPropertyDescription2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRelativeDescriptionType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), propvar1, propvar2, ppszdesc1, ppszdesc2).ok() + pub unsafe fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), ppszdesc1, ppszdesc2).ok() } pub unsafe fn GetSortDescription(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1234,37 +1177,26 @@ impl IPropertyDescription2 { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetEnumTypeList)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ppropvar).ok() + pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), propvar, pdfflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), pdfflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), propvar).ok() + pub unsafe fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetImageReferenceForValue(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn GetImageReferenceForValue(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetImageReferenceForValue)(::windows_core::Interface::as_raw(self), propvar, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetImageReferenceForValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), &mut result__).from_abi(result__) } } #[repr(C)] #[doc(hidden)] pub struct IPropertyDescription2_Vtbl { pub base__: IPropertyDescription_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetImageReferenceForValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszimageres: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetImageReferenceForValue: usize, + pub GetImageReferenceForValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, ppszimageres: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyDescriptionAliasInfo, IPropertyDescriptionAliasInfo_Vtbl, 0xf67104fc_2af9_46fd_b32d_243c1404f3d1); ::windows_core::imp::interface_hierarchy!(IPropertyDescriptionAliasInfo, ::windows_core::IUnknown, IPropertyDescription); @@ -1316,10 +1248,8 @@ impl IPropertyDescriptionAliasInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRelativeDescriptionType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), propvar1, propvar2, ppszdesc1, ppszdesc2).ok() + pub unsafe fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), ppszdesc1, ppszdesc2).ok() } pub unsafe fn GetSortDescription(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1348,21 +1278,15 @@ impl IPropertyDescriptionAliasInfo { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetEnumTypeList)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ppropvar).ok() + pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), propvar, pdfflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), pdfflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), propvar).ok() + pub unsafe fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar)).ok() } pub unsafe fn GetSortByAlias(&self) -> ::windows_core::Result where @@ -1458,10 +1382,8 @@ impl IPropertyDescriptionRelatedPropertyInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRelativeDescriptionType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), propvar1, propvar2, ppszdesc1, ppszdesc2).ok() + pub unsafe fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), ppszdesc1, ppszdesc2).ok() } pub unsafe fn GetSortDescription(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1490,21 +1412,15 @@ impl IPropertyDescriptionRelatedPropertyInfo { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetEnumTypeList)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ppropvar).ok() + pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), propvar, pdfflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), pdfflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), propvar).ok() + pub unsafe fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar)).ok() } pub unsafe fn GetRelatedProperty(&self, pszrelationshipname: P0) -> ::windows_core::Result where @@ -1571,10 +1487,8 @@ impl IPropertyDescriptionSearchInfo { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRelativeDescriptionType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRelativeDescription(&self, propvar1: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, propvar2: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), propvar1, propvar2, ppszdesc1, ppszdesc2).ok() + pub unsafe fn GetRelativeDescription(&self, propvar1: *const ::windows_core::PROPVARIANT, propvar2: *const ::windows_core::PROPVARIANT, ppszdesc1: *mut ::windows_core::PWSTR, ppszdesc2: *mut ::windows_core::PWSTR) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.GetRelativeDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar1), ::core::mem::transmute(propvar2), ppszdesc1, ppszdesc2).ok() } pub unsafe fn GetSortDescription(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1603,21 +1517,15 @@ impl IPropertyDescriptionSearchInfo { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).base__.GetEnumTypeList)(::windows_core::Interface::as_raw(self), &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ppropvar).ok() + pub unsafe fn CoerceToCanonicalValue(&self, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.CoerceToCanonicalValue)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(ppropvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplay(&self, propvar: *const ::windows_core::PROPVARIANT, pdfflags: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), propvar, pdfflags, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.FormatForDisplay)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar), pdfflags, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn IsValueCanonical(&self, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), propvar).ok() + pub unsafe fn IsValueCanonical(&self, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.IsValueCanonical)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvar)).ok() } pub unsafe fn GetSearchInfoFlags(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1652,21 +1560,15 @@ impl IPropertyEnumType { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetEnumType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRangeMinValue(&self) -> ::windows_core::Result { + pub unsafe fn GetRangeMinValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRangeMinValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRangeSetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetRangeSetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetRangeSetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1680,18 +1582,9 @@ impl IPropertyEnumType { pub struct IPropertyEnumType_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetEnumType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, penumtype: *mut PROPENUMTYPE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetRangeMinValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarmin: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetRangeMinValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetRangeSetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarset: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetRangeSetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetRangeMinValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarmin: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub GetRangeSetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppropvarset: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub GetDisplayText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyEnumType2, IPropertyEnumType2_Vtbl, 0x9b6e051c_5ddd_4321_9070_fe2acb55e794); @@ -1701,21 +1594,15 @@ impl IPropertyEnumType2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetEnumType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRangeMinValue(&self) -> ::windows_core::Result { + pub unsafe fn GetRangeMinValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRangeMinValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetRangeSetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetRangeSetValue(&self) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetRangeSetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1755,11 +1642,9 @@ impl IPropertyEnumTypeList { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).GetConditionAt)(::windows_core::Interface::as_raw(self), nindex, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FindMatchingIndex(&self, propvarcmp: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result { + pub unsafe fn FindMatchingIndex(&self, propvarcmp: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FindMatchingIndex)(::windows_core::Interface::as_raw(self), propvarcmp, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FindMatchingIndex)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(propvarcmp), &mut result__).from_abi(result__) } } #[repr(C)] @@ -1769,10 +1654,7 @@ pub struct IPropertyEnumTypeList_Vtbl { pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pctypes: *mut u32) -> ::windows_core::HRESULT, pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itype: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetConditionAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, nindex: u32, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub FindMatchingIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvarcmp: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pnindex: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - FindMatchingIndex: usize, + pub FindMatchingIndex: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propvarcmp: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pnindex: *mut u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyStore, IPropertyStore_Vtbl, 0x886d8eeb_8cf2_4446_8d02_cdba1dbdcf99); ::windows_core::imp::interface_hierarchy!(IPropertyStore, ::windows_core::IUnknown); @@ -1784,16 +1666,12 @@ impl IPropertyStore { pub unsafe fn GetAt(&self, iprop: u32, pkey: *mut PROPERTYKEY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetAt)(::windows_core::Interface::as_raw(self), iprop, pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result { + pub unsafe fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), key, propvar).ok() + pub unsafe fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar)).ok() } pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Commit)(::windows_core::Interface::as_raw(self)).ok() @@ -1805,14 +1683,8 @@ pub struct IPropertyStore_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cprops: *mut u32) -> ::windows_core::HRESULT, pub GetAt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iprop: u32, pkey: *mut PROPERTYKEY) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pv: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub Commit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyStoreCache, IPropertyStoreCache_Vtbl, 0x3017056d_9a91_4e90_937d_746c72abbf4f); @@ -1825,16 +1697,12 @@ impl IPropertyStoreCache { pub unsafe fn GetAt(&self, iprop: u32, pkey: *mut PROPERTYKEY) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GetAt)(::windows_core::Interface::as_raw(self), iprop, pkey).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result { + pub unsafe fn GetValue(&self, key: *const PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, propvar).ok() + pub unsafe fn SetValue(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SetValue)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar)).ok() } pub unsafe fn Commit(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Commit)(::windows_core::Interface::as_raw(self)).ok() @@ -1843,18 +1711,14 @@ impl IPropertyStoreCache { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetState)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn GetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).GetValueAndState)(::windows_core::Interface::as_raw(self), key, ppropvar, pstate).ok() + pub unsafe fn GetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *mut ::windows_core::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).GetValueAndState)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(ppropvar), pstate).ok() } pub unsafe fn SetState(&self, key: *const PROPERTYKEY, state: PSC_STATE) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetState)(::windows_core::Interface::as_raw(self), key, state).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn SetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, state: PSC_STATE) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValueAndState)(::windows_core::Interface::as_raw(self), key, ppropvar, state).ok() + pub unsafe fn SetValueAndState(&self, key: *const PROPERTYKEY, ppropvar: *const ::windows_core::PROPVARIANT, state: PSC_STATE) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValueAndState)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(ppropvar), state).ok() } } #[repr(C)] @@ -1862,15 +1726,9 @@ impl IPropertyStoreCache { pub struct IPropertyStoreCache_Vtbl { pub base__: IPropertyStore_Vtbl, pub GetState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub GetValueAndState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *mut super::super::super::System::Com::StructuredStorage::PROPVARIANT, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - GetValueAndState: usize, + pub GetValueAndState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pstate: *mut PSC_STATE) -> ::windows_core::HRESULT, pub SetState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, state: PSC_STATE) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub SetValueAndState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, state: PSC_STATE) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - SetValueAndState: usize, + pub SetValueAndState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, state: PSC_STATE) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IPropertyStoreCapabilities, IPropertyStoreCapabilities_Vtbl, 0xc8e2d566_186e_4d49_bf41_6909ead56acc); ::windows_core::imp::interface_hierarchy!(IPropertyStoreCapabilities, ::windows_core::IUnknown); @@ -1944,16 +1802,12 @@ impl IPropertySystem { let mut result__ = ::std::ptr::null_mut(); (::windows_core::Interface::vtable(self).EnumeratePropertyDescriptions)(::windows_core::Interface::as_raw(self), filteron, &T::IID, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: &mut [u16]) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), key, propvar, pdff, ::core::mem::transmute(psztext.as_ptr()), psztext.len().try_into().unwrap()).ok() + pub unsafe fn FormatForDisplay(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: &mut [u16]) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar), pdff, ::core::mem::transmute(psztext.as_ptr()), psztext.len().try_into().unwrap()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplayAlloc(&self, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { + pub unsafe fn FormatForDisplayAlloc(&self, key: *const PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS) -> ::windows_core::Result<::windows_core::PWSTR> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).FormatForDisplayAlloc)(::windows_core::Interface::as_raw(self), key, propvar, pdff, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).FormatForDisplayAlloc)(::windows_core::Interface::as_raw(self), key, ::core::mem::transmute(propvar), pdff, &mut result__).from_abi(result__) } pub unsafe fn RegisterPropertySchema(&self, pszpath: P0) -> ::windows_core::Result<()> where @@ -1979,14 +1833,8 @@ pub struct IPropertySystem_Vtbl { pub GetPropertyDescriptionByName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszcanonicalname: ::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetPropertyDescriptionListFromString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszproplist: ::windows_core::PCWSTR, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EnumeratePropertyDescriptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, filteron: PROPDESC_ENUMFILTER, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - FormatForDisplay: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub FormatForDisplayAlloc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, pdff: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - FormatForDisplayAlloc: usize, + pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdff: PROPDESC_FORMAT_FLAGS, psztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT, + pub FormatForDisplayAlloc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, pdff: PROPDESC_FORMAT_FLAGS, ppszdisplay: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, pub RegisterPropertySchema: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpath: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub UnregisterPropertySchema: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszpath: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, pub RefreshPropertySchema: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2030,10 +1878,8 @@ impl IPropertyUI { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFlags)(::windows_core::Interface::as_raw(self), fmtid, pid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn FormatForDisplay(&self, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: &mut [u16]) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), fmtid, pid, ppropvar, puiff, ::core::mem::transmute(pwsztext.as_ptr()), pwsztext.len().try_into().unwrap()).ok() + pub unsafe fn FormatForDisplay(&self, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const ::windows_core::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: &mut [u16]) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).FormatForDisplay)(::windows_core::Interface::as_raw(self), fmtid, pid, ::core::mem::transmute(ppropvar), puiff, ::core::mem::transmute(pwsztext.as_ptr()), pwsztext.len().try_into().unwrap()).ok() } pub unsafe fn GetHelpInfo(&self, fmtid: *const ::windows_core::GUID, pid: u32, pwszhelpfile: &mut [u16], puhelpid: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetHelpInfo)(::windows_core::Interface::as_raw(self), fmtid, pid, ::core::mem::transmute(pwszhelpfile.as_ptr()), pwszhelpfile.len().try_into().unwrap(), puhelpid).ok() @@ -2049,10 +1895,7 @@ pub struct IPropertyUI_Vtbl { pub GetPropertyDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT, pub GetDefaultWidth: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, pcxchars: *mut u32) -> ::windows_core::HRESULT, pub GetFlags: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, pflags: *mut PROPERTYUI_FLAGS) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const super::super::super::System::Com::StructuredStorage::PROPVARIANT, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - FormatForDisplay: usize, + pub FormatForDisplay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, ppropvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>, puiff: PROPERTYUI_FORMAT_FLAGS, pwsztext: ::windows_core::PWSTR, cchtext: u32) -> ::windows_core::HRESULT, pub GetHelpInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fmtid: *const ::windows_core::GUID, pid: u32, pwszhelpfile: ::windows_core::PWSTR, cch: u32, puhelpid: *mut u32) -> ::windows_core::HRESULT, } pub const FPSPS_DEFAULT: _PERSIST_SPROPSTORE_FLAGS = _PERSIST_SPROPSTORE_FLAGS(0i32); diff --git a/crates/libs/windows/src/Windows/Win32/UI/Shell/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/Shell/impl.rs index c28d05ee40..d45837e6aa 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Shell/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Shell/impl.rs @@ -1,12 +1,12 @@ -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_Common\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common"))] pub trait CIE4ConnectionPoint_Impl: Sized + super::super::System::Com::IConnectionPoint_Impl { fn DoInvokeIE4(&self, pf: *mut super::super::Foundation::BOOL, ppv: *mut *mut ::core::ffi::c_void, dispid: i32, pdispparams: *mut super::super::System::Com::DISPPARAMS) -> ::windows_core::Result<()>; fn DoInvokePIDLIE4(&self, dispid: i32, pidl: *mut Common::ITEMIDLIST, fcancancel: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common"))] impl ::windows_core::RuntimeName for CIE4ConnectionPoint {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common"))] impl CIE4ConnectionPoint_Vtbl { pub const fn new, Impl: CIE4ConnectionPoint_Impl, const OFFSET: isize>() -> CIE4ConnectionPoint_Vtbl { unsafe extern "system" fn DoInvokeIE4, Impl: CIE4ConnectionPoint_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pf: *mut super::super::Foundation::BOOL, ppv: *mut *mut ::core::ffi::c_void, dispid: i32, pdispparams: *mut super::super::System::Com::DISPPARAMS) -> ::windows_core::HRESULT { @@ -29,15 +29,15 @@ impl CIE4ConnectionPoint_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DFConstraint_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Value(&self) -> ::windows_core::Result; + fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DFConstraint {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DFConstraint_Vtbl { pub const fn new, Impl: DFConstraint_Impl, const OFFSET: isize>() -> DFConstraint_Vtbl { unsafe extern "system" fn Name, Impl: DFConstraint_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -51,7 +51,7 @@ impl DFConstraint_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Value, Impl: DFConstraint_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Value, Impl: DFConstraint_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Value() { @@ -72,12 +72,12 @@ impl DFConstraint_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DShellFolderViewEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DShellFolderViewEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DShellFolderViewEvents_Vtbl { pub const fn new, Impl: DShellFolderViewEvents_Impl, const OFFSET: isize>() -> DShellFolderViewEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -86,12 +86,12 @@ impl DShellFolderViewEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DShellNameSpaceEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DShellNameSpaceEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DShellNameSpaceEvents_Vtbl { pub const fn new, Impl: DShellNameSpaceEvents_Impl, const OFFSET: isize>() -> DShellNameSpaceEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -100,12 +100,12 @@ impl DShellNameSpaceEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DShellWindowsEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DShellWindowsEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DShellWindowsEvents_Vtbl { pub const fn new, Impl: DShellWindowsEvents_Impl, const OFFSET: isize>() -> DShellWindowsEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -114,12 +114,12 @@ impl DShellWindowsEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DWebBrowserEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DWebBrowserEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DWebBrowserEvents_Vtbl { pub const fn new, Impl: DWebBrowserEvents_Impl, const OFFSET: isize>() -> DWebBrowserEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -128,12 +128,12 @@ impl DWebBrowserEvents_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait DWebBrowserEvents2_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for DWebBrowserEvents2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl DWebBrowserEvents2_Vtbl { pub const fn new, Impl: DWebBrowserEvents2_Impl, const OFFSET: isize>() -> DWebBrowserEvents2_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -142,8 +142,8 @@ impl DWebBrowserEvents2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Folder_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Title(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Application(&self) -> ::windows_core::Result; @@ -151,14 +151,14 @@ pub trait Folder_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ParentFolder(&self) -> ::windows_core::Result; fn Items(&self) -> ::windows_core::Result; fn ParseName(&self, bname: &::windows_core::BSTR) -> ::windows_core::Result; - fn NewFolder(&self, bname: &::windows_core::BSTR, voptions: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn MoveHere(&self, vitem: &super::super::System::Variant::VARIANT, voptions: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn CopyHere(&self, vitem: &super::super::System::Variant::VARIANT, voptions: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetDetailsOf(&self, vitem: &super::super::System::Variant::VARIANT, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR>; + fn NewFolder(&self, bname: &::windows_core::BSTR, voptions: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn MoveHere(&self, vitem: &::windows_core::VARIANT, voptions: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn CopyHere(&self, vitem: &::windows_core::VARIANT, voptions: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetDetailsOf(&self, vitem: &::windows_core::VARIANT, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Folder {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Folder_Vtbl { pub const fn new, Impl: Folder_Impl, const OFFSET: isize>() -> Folder_Vtbl { unsafe extern "system" fn Title, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -227,22 +227,22 @@ impl Folder_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NewFolder, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bname: ::std::mem::MaybeUninit<::windows_core::BSTR>, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NewFolder, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bname: ::std::mem::MaybeUninit<::windows_core::BSTR>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.NewFolder(::core::mem::transmute(&bname), ::core::mem::transmute(&voptions)).into() } - unsafe extern "system" fn MoveHere, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn MoveHere, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.MoveHere(::core::mem::transmute(&vitem), ::core::mem::transmute(&voptions)).into() } - unsafe extern "system" fn CopyHere, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CopyHere, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CopyHere(::core::mem::transmute(&vitem), ::core::mem::transmute(&voptions)).into() } - unsafe extern "system" fn GetDetailsOf, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, icolumn: i32, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDetailsOf, Impl: Folder_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, icolumn: i32, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDetailsOf(::core::mem::transmute(&vitem), ::core::mem::transmute_copy(&icolumn)) { @@ -271,8 +271,8 @@ impl Folder_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Folder2_Impl: Sized + Folder_Impl { fn Self_(&self) -> ::windows_core::Result; fn OfflineStatus(&self) -> ::windows_core::Result; @@ -280,9 +280,9 @@ pub trait Folder2_Impl: Sized + Folder_Impl { fn HaveToShowWebViewBarricade(&self) -> ::windows_core::Result; fn DismissedWebViewBarricade(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Folder2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Folder2_Vtbl { pub const fn new, Impl: Folder2_Impl, const OFFSET: isize>() -> Folder2_Vtbl { unsafe extern "system" fn Self_, Impl: Folder2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppfi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -341,15 +341,15 @@ impl Folder2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Folder3_Impl: Sized + Folder2_Impl { fn ShowWebViewBarricade(&self) -> ::windows_core::Result; fn SetShowWebViewBarricade(&self, bshowwebviewbarricade: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Folder3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Folder3_Vtbl { pub const fn new, Impl: Folder3_Impl, const OFFSET: isize>() -> Folder3_Vtbl { unsafe extern "system" fn ShowWebViewBarricade, Impl: Folder3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbshowwebviewbarricade: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -378,8 +378,8 @@ impl Folder3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; @@ -397,11 +397,11 @@ pub trait FolderItem_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Size(&self) -> ::windows_core::Result; fn Type(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Verbs(&self) -> ::windows_core::Result; - fn InvokeVerb(&self, vverb: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn InvokeVerb(&self, vverb: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItem {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItem_Vtbl { pub const fn new, Impl: FolderItem_Impl, const OFFSET: isize>() -> FolderItem_Vtbl { unsafe extern "system" fn Application, Impl: FolderItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -568,7 +568,7 @@ impl FolderItem_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn InvokeVerb, Impl: FolderItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeVerb, Impl: FolderItem_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeVerb(::core::mem::transmute(&vverb)).into() @@ -598,23 +598,23 @@ impl FolderItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItem2_Impl: Sized + FolderItem_Impl { - fn InvokeVerbEx(&self, vverb: &super::super::System::Variant::VARIANT, vargs: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ExtendedProperty(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result; + fn InvokeVerbEx(&self, vverb: &::windows_core::VARIANT, vargs: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ExtendedProperty(&self, bstrpropname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItem2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItem2_Vtbl { pub const fn new, Impl: FolderItem2_Impl, const OFFSET: isize>() -> FolderItem2_Vtbl { - unsafe extern "system" fn InvokeVerbEx, Impl: FolderItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeVerbEx, Impl: FolderItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeVerbEx(::core::mem::transmute(&vverb), ::core::mem::transmute(&vargs)).into() } - unsafe extern "system" fn ExtendedProperty, Impl: FolderItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvret: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExtendedProperty, Impl: FolderItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvret: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExtendedProperty(::core::mem::transmute(&bstrpropname)) { @@ -635,17 +635,17 @@ impl FolderItem2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItemVerb_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn DoIt(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItemVerb {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItemVerb_Vtbl { pub const fn new, Impl: FolderItemVerb_Impl, const OFFSET: isize>() -> FolderItemVerb_Vtbl { unsafe extern "system" fn Application, Impl: FolderItemVerb_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -698,18 +698,18 @@ impl FolderItemVerb_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItemVerbs_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; - fn Item(&self, index: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItemVerbs {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItemVerbs_Vtbl { pub const fn new, Impl: FolderItemVerbs_Impl, const OFFSET: isize>() -> FolderItemVerbs_Vtbl { unsafe extern "system" fn Count, Impl: FolderItemVerbs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -745,7 +745,7 @@ impl FolderItemVerbs_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: FolderItemVerbs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: FolderItemVerbs_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&index)) { @@ -780,18 +780,18 @@ impl FolderItemVerbs_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItems_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; - fn Item(&self, index: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItems {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItems_Vtbl { pub const fn new, Impl: FolderItems_Impl, const OFFSET: isize>() -> FolderItems_Vtbl { unsafe extern "system" fn Count, Impl: FolderItems_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT { @@ -827,7 +827,7 @@ impl FolderItems_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: FolderItems_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: FolderItems_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&index)) { @@ -862,17 +862,17 @@ impl FolderItems_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItems2_Impl: Sized + FolderItems_Impl { - fn InvokeVerbEx(&self, vverb: &super::super::System::Variant::VARIANT, vargs: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn InvokeVerbEx(&self, vverb: &::windows_core::VARIANT, vargs: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItems2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItems2_Vtbl { pub const fn new, Impl: FolderItems2_Impl, const OFFSET: isize>() -> FolderItems2_Vtbl { - unsafe extern "system" fn InvokeVerbEx, Impl: FolderItems2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InvokeVerbEx, Impl: FolderItems2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InvokeVerbEx(::core::mem::transmute(&vverb), ::core::mem::transmute(&vargs)).into() @@ -883,15 +883,15 @@ impl FolderItems2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait FolderItems3_Impl: Sized + FolderItems2_Impl { fn Filter(&self, grfflags: i32, bstrfilespec: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Verbs(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for FolderItems3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl FolderItems3_Vtbl { pub const fn new, Impl: FolderItems3_Impl, const OFFSET: isize>() -> FolderItems3_Vtbl { unsafe extern "system" fn Filter, Impl: FolderItems3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, grfflags: i32, bstrfilespec: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2223,8 +2223,8 @@ impl IBrowserFrameOptions_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_UI_Shell_Common\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Shell_Common"))] pub trait IBrowserService_Impl: Sized { fn GetParentSite(&self) -> ::windows_core::Result; fn SetTitle(&self, psv: ::core::option::Option<&IShellView>, pszname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; @@ -2252,14 +2252,14 @@ pub trait IBrowserService_Impl: Sized { fn GetHistoryObject(&self, ppole: *mut ::core::option::Option, pstm: *mut ::core::option::Option, ppbc: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn SetHistoryObject(&self, pole: ::core::option::Option<&super::super::System::Ole::IOleObject>, fislocalanchor: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn CacheOLEServer(&self, pole: ::core::option::Option<&super::super::System::Ole::IOleObject>) -> ::windows_core::Result<()>; - fn GetSetCodePage(&self, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn OnHttpEquiv(&self, psv: ::core::option::Option<&IShellView>, fdone: super::super::Foundation::BOOL, pvarargin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn GetSetCodePage(&self, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn OnHttpEquiv(&self, psv: ::core::option::Option<&IShellView>, fdone: super::super::Foundation::BOOL, pvarargin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetPalette(&self) -> ::windows_core::Result; fn RegisterWindow(&self, fforceregister: super::super::Foundation::BOOL, swc: ShellWindowTypeConstants) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Shell_Common"))] impl ::windows_core::RuntimeName for IBrowserService {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Shell_Common"))] impl IBrowserService_Vtbl { pub const fn new, Impl: IBrowserService_Impl, const OFFSET: isize>() -> IBrowserService_Vtbl { unsafe extern "system" fn GetParentSite, Impl: IBrowserService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppipsite: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -2452,7 +2452,7 @@ impl IBrowserService_Vtbl { let this = (*this).get_impl(); this.CacheOLEServer(::windows_core::from_raw_borrowed(&pole)).into() } - unsafe extern "system" fn GetSetCodePage, Impl: IBrowserService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarin: *const super::super::System::Variant::VARIANT, pvarout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSetCodePage, Impl: IBrowserService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSetCodePage(::core::mem::transmute_copy(&pvarin)) { @@ -2463,7 +2463,7 @@ impl IBrowserService_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn OnHttpEquiv, Impl: IBrowserService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psv: *mut ::core::ffi::c_void, fdone: super::super::Foundation::BOOL, pvarargin: *const super::super::System::Variant::VARIANT, pvarargout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnHttpEquiv, Impl: IBrowserService_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psv: *mut ::core::ffi::c_void, fdone: super::super::Foundation::BOOL, pvarargin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarargout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OnHttpEquiv(::windows_core::from_raw_borrowed(&psv), ::core::mem::transmute_copy(&fdone), ::core::mem::transmute_copy(&pvarargin)) { @@ -2528,8 +2528,8 @@ impl IBrowserService_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IBrowserService2_Impl: Sized + IBrowserService_Impl { fn WndProcBS(&self, hwnd: super::super::Foundation::HWND, umsg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> super::super::Foundation::LRESULT; fn SetAsDefFolderSettings(&self) -> ::windows_core::Result<()>; @@ -2565,7 +2565,7 @@ pub trait IBrowserService2_Impl: Sized + IBrowserService_Impl { fn _NavigateToPidl2(&self, pidl: *const Common::ITEMIDLIST, grfhlnf: u32, dwflags: u32) -> ::windows_core::Result<()>; fn _TryShell2Rename(&self, psv: ::core::option::Option<&IShellView>, pidlnew: *const Common::ITEMIDLIST) -> ::windows_core::Result<()>; fn _SwitchActivationNow(&self) -> ::windows_core::Result<()>; - fn _ExecChildren(&self, punkbar: ::core::option::Option<&::windows_core::IUnknown>, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const super::super::System::Variant::VARIANT, pvarargout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn _ExecChildren(&self, punkbar: ::core::option::Option<&::windows_core::IUnknown>, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const ::windows_core::VARIANT, pvarargout: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn _SendChildren(&self, hwndbar: super::super::Foundation::HWND, fbroadcast: super::super::Foundation::BOOL, umsg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows_core::Result<()>; fn GetFolderSetData(&self, pfsd: *mut FOLDERSETDATA) -> ::windows_core::Result<()>; fn _OnFocusChange(&self, itb: u32) -> ::windows_core::Result<()>; @@ -2594,9 +2594,9 @@ pub trait IBrowserService2_Impl: Sized + IBrowserService_Impl { fn _GetBorderDWHelper(&self, punksrc: ::core::option::Option<&::windows_core::IUnknown>, lprectborder: *mut super::super::Foundation::RECT, busehmonitor: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn v_CheckZoneCrossing(&self, pidl: *const Common::ITEMIDLIST) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IBrowserService2 {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl IBrowserService2_Vtbl { pub const fn new, Impl: IBrowserService2_Impl, const OFFSET: isize>() -> IBrowserService2_Vtbl { unsafe extern "system" fn WndProcBS, Impl: IBrowserService2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, umsg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> super::super::Foundation::LRESULT { @@ -2793,7 +2793,7 @@ impl IBrowserService2_Vtbl { let this = (*this).get_impl(); this._SwitchActivationNow().into() } - unsafe extern "system" fn _ExecChildren, Impl: IBrowserService2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkbar: *mut ::core::ffi::c_void, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const super::super::System::Variant::VARIANT, pvarargout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn _ExecChildren, Impl: IBrowserService2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkbar: *mut ::core::ffi::c_void, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarargout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this._ExecChildren(::windows_core::from_raw_borrowed(&punkbar), ::core::mem::transmute_copy(&fbroadcast), ::core::mem::transmute_copy(&pguidcmdgroup), ::core::mem::transmute_copy(&ncmdid), ::core::mem::transmute_copy(&ncmdexecopt), ::core::mem::transmute_copy(&pvarargin), ::core::mem::transmute_copy(&pvarargout)).into() @@ -3003,15 +3003,15 @@ impl IBrowserService2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IBrowserService3_Impl: Sized + IBrowserService2_Impl { fn _PositionViewWindow(&self, hwnd: super::super::Foundation::HWND, prc: *const super::super::Foundation::RECT) -> ::windows_core::Result<()>; fn IEParseDisplayNameEx(&self, uicp: u32, pwszpath: &::windows_core::PCWSTR, dwflags: u32) -> ::windows_core::Result<*mut Common::ITEMIDLIST>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IBrowserService3 {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl IBrowserService3_Vtbl { pub const fn new, Impl: IBrowserService3_Impl, const OFFSET: isize>() -> IBrowserService3_Vtbl { unsafe extern "system" fn _PositionViewWindow, Impl: IBrowserService3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: super::super::Foundation::HWND, prc: *const super::super::Foundation::RECT) -> ::windows_core::HRESULT { @@ -3040,16 +3040,16 @@ impl IBrowserService3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_UI_Controls\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IBrowserService4_Impl: Sized + IBrowserService3_Impl { fn ActivateView(&self, fpendingview: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn SaveViewState(&self) -> ::windows_core::Result<()>; fn _ResizeAllBorders(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IBrowserService4 {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_UI_Controls", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_WindowsAndMessaging"))] impl IBrowserService4_Vtbl { pub const fn new, Impl: IBrowserService4_Impl, const OFFSET: isize>() -> IBrowserService4_Vtbl { unsafe extern "system" fn ActivateView, Impl: IBrowserService4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fpendingview: super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -3315,16 +3315,16 @@ impl IColumnManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IColumnProvider_Impl: Sized { fn Initialize(&self, psci: *const SHCOLUMNINIT) -> ::windows_core::Result<()>; fn GetColumnInfo(&self, dwindex: u32, psci: *mut SHCOLUMNINFO) -> ::windows_core::Result<()>; - fn GetItemData(&self, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA) -> ::windows_core::Result; + fn GetItemData(&self, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IColumnProvider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IColumnProvider_Vtbl { pub const fn new, Impl: IColumnProvider_Impl, const OFFSET: isize>() -> IColumnProvider_Vtbl { unsafe extern "system" fn Initialize, Impl: IColumnProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psci: *const SHCOLUMNINIT) -> ::windows_core::HRESULT { @@ -3337,7 +3337,7 @@ impl IColumnProvider_Vtbl { let this = (*this).get_impl(); this.GetColumnInfo(::core::mem::transmute_copy(&dwindex), ::core::mem::transmute_copy(&psci)).into() } - unsafe extern "system" fn GetItemData, Impl: IColumnProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA, pvardata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetItemData, Impl: IColumnProvider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA, pvardata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetItemData(::core::mem::transmute_copy(&pscid), ::core::mem::transmute_copy(&pscd)) { @@ -4276,17 +4276,17 @@ impl ICredentialProviderSetUserArray_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub trait ICredentialProviderUser_Impl: Sized { fn GetSid(&self) -> ::windows_core::Result<::windows_core::PWSTR>; fn GetProviderID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetStringValue(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PWSTR>; - fn GetValue(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetValue(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ::windows_core::RuntimeName for ICredentialProviderUser {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] impl ICredentialProviderUser_Vtbl { pub const fn new, Impl: ICredentialProviderUser_Impl, const OFFSET: isize>() -> ICredentialProviderUser_Vtbl { unsafe extern "system" fn GetSid, Impl: ICredentialProviderUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, sid: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -4322,7 +4322,7 @@ impl ICredentialProviderUser_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetValue, Impl: ICredentialProviderUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ICredentialProviderUser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&key)) { @@ -5218,17 +5218,13 @@ impl IDisplayItem_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IDocViewSite_Impl: Sized { - fn OnSetTitle(&self, pvtitle: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OnSetTitle(&self, pvtitle: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IDocViewSite {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IDocViewSite_Vtbl { pub const fn new, Impl: IDocViewSite_Impl, const OFFSET: isize>() -> IDocViewSite_Vtbl { - unsafe extern "system" fn OnSetTitle, Impl: IDocViewSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtitle: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnSetTitle, Impl: IDocViewSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtitle: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnSetTitle(::core::mem::transmute_copy(&pvtitle)).into() @@ -6304,16 +6300,16 @@ impl IExecuteCommandHost_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IExpDispSupport_Impl: Sized { fn FindConnectionPoint(&self, riid: *const ::windows_core::GUID) -> ::windows_core::Result; fn OnTranslateAccelerator(&self, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::Result<()>; - fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IExpDispSupport {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl IExpDispSupport_Vtbl { pub const fn new, Impl: IExpDispSupport_Impl, const OFFSET: isize>() -> IExpDispSupport_Vtbl { unsafe extern "system" fn FindConnectionPoint, Impl: IExpDispSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppccp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6332,7 +6328,7 @@ impl IExpDispSupport_Vtbl { let this = (*this).get_impl(); this.OnTranslateAccelerator(::core::mem::transmute_copy(&pmsg), ::core::mem::transmute_copy(&grfmodifiers)).into() } - unsafe extern "system" fn OnInvoke, Impl: IExpDispSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnInvoke, Impl: IExpDispSupport_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnInvoke(::core::mem::transmute_copy(&dispidmember), ::core::mem::transmute_copy(&iid), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() @@ -6348,16 +6344,16 @@ impl IExpDispSupport_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_WindowsAndMessaging\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_WindowsAndMessaging\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] pub trait IExpDispSupportXP_Impl: Sized { fn FindCIE4ConnectionPoint(&self, riid: *const ::windows_core::GUID) -> ::windows_core::Result; fn OnTranslateAccelerator(&self, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::Result<()>; - fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; + fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl ::windows_core::RuntimeName for IExpDispSupportXP {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_WindowsAndMessaging"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_WindowsAndMessaging"))] impl IExpDispSupportXP_Vtbl { pub const fn new, Impl: IExpDispSupportXP_Impl, const OFFSET: isize>() -> IExpDispSupportXP_Vtbl { unsafe extern "system" fn FindCIE4ConnectionPoint, Impl: IExpDispSupportXP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, ppccp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6376,7 +6372,7 @@ impl IExpDispSupportXP_Vtbl { let this = (*this).get_impl(); this.OnTranslateAccelerator(::core::mem::transmute_copy(&pmsg), ::core::mem::transmute_copy(&grfmodifiers)).into() } - unsafe extern "system" fn OnInvoke, Impl: IExpDispSupportXP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnInvoke, Impl: IExpDispSupportXP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnInvoke(::core::mem::transmute_copy(&dispidmember), ::core::mem::transmute_copy(&iid), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute_copy(&wflags), ::core::mem::transmute_copy(&pdispparams), ::core::mem::transmute_copy(&pvarresult), ::core::mem::transmute_copy(&pexcepinfo), ::core::mem::transmute_copy(&puargerr)).into() @@ -7998,18 +7994,18 @@ impl IFileSaveDialog_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFileSearchBand_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetFocus(&self) -> ::windows_core::Result<()>; - fn SetSearchParameters(&self, pbstrsearchid: *const ::windows_core::BSTR, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const super::super::System::Variant::VARIANT, pvarqueryfile: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetSearchParameters(&self, pbstrsearchid: *const ::windows_core::BSTR, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const ::windows_core::VARIANT, pvarqueryfile: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SearchID(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Scope(&self) -> ::windows_core::Result; - fn QueryFile(&self) -> ::windows_core::Result; + fn Scope(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn QueryFile(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFileSearchBand {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFileSearchBand_Vtbl { pub const fn new, Impl: IFileSearchBand_Impl, const OFFSET: isize>() -> IFileSearchBand_Vtbl { unsafe extern "system" fn SetFocus, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -8017,7 +8013,7 @@ impl IFileSearchBand_Vtbl { let this = (*this).get_impl(); this.SetFocus().into() } - unsafe extern "system" fn SetSearchParameters, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsearchid: *const ::std::mem::MaybeUninit<::windows_core::BSTR>, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const super::super::System::Variant::VARIANT, pvarqueryfile: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSearchParameters, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrsearchid: *const ::std::mem::MaybeUninit<::windows_core::BSTR>, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarqueryfile: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSearchParameters(::core::mem::transmute_copy(&pbstrsearchid), ::core::mem::transmute_copy(&bnavtoresults), ::core::mem::transmute_copy(&pvarscope), ::core::mem::transmute_copy(&pvarqueryfile)).into() @@ -8033,7 +8029,7 @@ impl IFileSearchBand_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Scope, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarscope: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Scope, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarscope: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Scope() { @@ -8044,7 +8040,7 @@ impl IFileSearchBand_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn QueryFile, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarfile: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn QueryFile, Impl: IFileSearchBand_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarfile: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.QueryFile() { @@ -8439,13 +8435,13 @@ impl IFolderView_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IFolderView2_Impl: Sized + IFolderView_Impl { fn SetGroupBy(&self, key: *const PropertiesSystem::PROPERTYKEY, fascending: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetGroupBy(&self, pkey: *mut PropertiesSystem::PROPERTYKEY, pfascending: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn SetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn GetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn SetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn GetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn SetTileViewProperties(&self, pidl: *const Common::ITEMIDLIST, pszproplist: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn SetExtendedTileViewProperties(&self, pidl: *const Common::ITEMIDLIST, pszproplist: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; fn SetText(&self, itype: FVTEXTTYPE, pwsztext: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; @@ -8468,9 +8464,9 @@ pub trait IFolderView2_Impl: Sized + IFolderView_Impl { fn IsMoveInSameFolder(&self) -> ::windows_core::Result<()>; fn DoRename(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IFolderView2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IFolderView2_Vtbl { pub const fn new, Impl: IFolderView2_Impl, const OFFSET: isize>() -> IFolderView2_Vtbl { unsafe extern "system" fn SetGroupBy, Impl: IFolderView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, fascending: super::super::Foundation::BOOL) -> ::windows_core::HRESULT { @@ -8483,12 +8479,12 @@ impl IFolderView2_Vtbl { let this = (*this).get_impl(); this.GetGroupBy(::core::mem::transmute_copy(&pkey), ::core::mem::transmute_copy(&pfascending)).into() } - unsafe extern "system" fn SetViewProperty, Impl: IFolderView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetViewProperty, Impl: IFolderView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetViewProperty(::core::mem::transmute_copy(&pidl), ::core::mem::transmute_copy(&propkey), ::core::mem::transmute_copy(&propvar)).into() } - unsafe extern "system" fn GetViewProperty, Impl: IFolderView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetViewProperty, Impl: IFolderView2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetViewProperty(::core::mem::transmute_copy(&pidl), ::core::mem::transmute_copy(&propkey)) { @@ -8700,14 +8696,14 @@ impl IFolderViewHost_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IFolderViewOC_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetFolderView(&self, pdisp: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IFolderViewOC {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IFolderViewOC_Vtbl { pub const fn new, Impl: IFolderViewOC_Impl, const OFFSET: isize>() -> IFolderViewOC_Vtbl { unsafe extern "system" fn SetFolderView, Impl: IFolderViewOC_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdisp: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -10488,16 +10484,12 @@ impl IModalWindow_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait INameSpaceTreeAccessible_Impl: Sized { fn OnGetDefaultAccessibilityAction(&self, psi: ::core::option::Option<&IShellItem>) -> ::windows_core::Result<::windows_core::BSTR>; fn OnDoDefaultAccessibilityAction(&self, psi: ::core::option::Option<&IShellItem>) -> ::windows_core::Result<()>; - fn OnGetAccessibilityRole(&self, psi: ::core::option::Option<&IShellItem>) -> ::windows_core::Result; + fn OnGetAccessibilityRole(&self, psi: ::core::option::Option<&IShellItem>) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for INameSpaceTreeAccessible {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl INameSpaceTreeAccessible_Vtbl { pub const fn new, Impl: INameSpaceTreeAccessible_Impl, const OFFSET: isize>() -> INameSpaceTreeAccessible_Vtbl { unsafe extern "system" fn OnGetDefaultAccessibilityAction, Impl: INameSpaceTreeAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pbstrdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -10516,7 +10508,7 @@ impl INameSpaceTreeAccessible_Vtbl { let this = (*this).get_impl(); this.OnDoDefaultAccessibilityAction(::windows_core::from_raw_borrowed(&psi)).into() } - unsafe extern "system" fn OnGetAccessibilityRole, Impl: INameSpaceTreeAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pvarrole: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnGetAccessibilityRole, Impl: INameSpaceTreeAccessible_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pvarrole: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.OnGetAccessibilityRole(::windows_core::from_raw_borrowed(&psi)) { @@ -11053,24 +11045,20 @@ impl INameSpaceTreeControlFolderCapabilities_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] pub trait INamedPropertyBag_Impl: Sized { - fn ReadPropertyNPB(&self, pszbagname: &::windows_core::PCWSTR, pszpropname: &::windows_core::PCWSTR, pvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; - fn WritePropertyNPB(&self, pszbagname: &::windows_core::PCWSTR, pszpropname: &::windows_core::PCWSTR, pvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()>; + fn ReadPropertyNPB(&self, pszbagname: &::windows_core::PCWSTR, pszpropname: &::windows_core::PCWSTR, pvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; + fn WritePropertyNPB(&self, pszbagname: &::windows_core::PCWSTR, pszpropname: &::windows_core::PCWSTR, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()>; fn RemovePropertyNPB(&self, pszbagname: &::windows_core::PCWSTR, pszpropname: &::windows_core::PCWSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for INamedPropertyBag {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] impl INamedPropertyBag_Vtbl { pub const fn new, Impl: INamedPropertyBag_Impl, const OFFSET: isize>() -> INamedPropertyBag_Vtbl { - unsafe extern "system" fn ReadPropertyNPB, Impl: INamedPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ReadPropertyNPB, Impl: INamedPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ReadPropertyNPB(::core::mem::transmute(&pszbagname), ::core::mem::transmute(&pszpropname), ::core::mem::transmute_copy(&pvar)).into() } - unsafe extern "system" fn WritePropertyNPB, Impl: INamedPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn WritePropertyNPB, Impl: INamedPropertyBag_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.WritePropertyNPB(::core::mem::transmute(&pszbagname), ::core::mem::transmute(&pszpropname), ::core::mem::transmute_copy(&pvar)).into() @@ -11385,14 +11373,14 @@ impl INewShortcutHookW_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait INewWDEvents_Impl: Sized + IWebWizardHost_Impl { fn PassportAuthenticate(&self, bstrsigninurl: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for INewWDEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl INewWDEvents_Vtbl { pub const fn new, Impl: INewWDEvents_Impl, const OFFSET: isize>() -> INewWDEvents_Vtbl { unsafe extern "system" fn PassportAuthenticate, Impl: INewWDEvents_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrsigninurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvfauthenitcated: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -12997,8 +12985,8 @@ impl IRunnableTask_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IScriptErrorList_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn advanceError(&self) -> ::windows_core::Result<()>; fn retreatError(&self) -> ::windows_core::Result<()>; @@ -13015,9 +13003,9 @@ pub trait IScriptErrorList_Impl: Sized + super::super::System::Com::IDispatch_Im fn getPerErrorDisplay(&self) -> ::windows_core::Result; fn setPerErrorDisplay(&self, fpererrordisplay: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IScriptErrorList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IScriptErrorList_Vtbl { pub const fn new, Impl: IScriptErrorList_Impl, const OFFSET: isize>() -> IScriptErrorList_Vtbl { unsafe extern "system" fn advanceError, Impl: IScriptErrorList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -13740,16 +13728,16 @@ impl IShellDetails_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; - fn NameSpace(&self, vdir: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn BrowseForFolder(&self, hwnd: i32, title: &::windows_core::BSTR, options: i32, rootfolder: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn NameSpace(&self, vdir: &::windows_core::VARIANT) -> ::windows_core::Result; + fn BrowseForFolder(&self, hwnd: i32, title: &::windows_core::BSTR, options: i32, rootfolder: &::windows_core::VARIANT) -> ::windows_core::Result; fn Windows(&self) -> ::windows_core::Result; - fn Open(&self, vdir: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn Explore(&self, vdir: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Open(&self, vdir: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn Explore(&self, vdir: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MinimizeAll(&self) -> ::windows_core::Result<()>; fn UndoMinimizeALL(&self) -> ::windows_core::Result<()>; fn FileRun(&self) -> ::windows_core::Result<()>; @@ -13767,9 +13755,9 @@ pub trait IShellDispatch_Impl: Sized + super::super::System::Com::IDispatch_Impl fn RefreshMenu(&self) -> ::windows_core::Result<()>; fn ControlPanelItem(&self, bstrdir: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch_Vtbl { pub const fn new, Impl: IShellDispatch_Impl, const OFFSET: isize>() -> IShellDispatch_Vtbl { unsafe extern "system" fn Application, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -13794,7 +13782,7 @@ impl IShellDispatch_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NameSpace, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn NameSpace, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.NameSpace(::core::mem::transmute(&vdir)) { @@ -13805,7 +13793,7 @@ impl IShellDispatch_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BrowseForFolder, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, options: i32, rootfolder: super::super::System::Variant::VARIANT, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn BrowseForFolder, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, options: i32, rootfolder: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BrowseForFolder(::core::mem::transmute_copy(&hwnd), ::core::mem::transmute(&title), ::core::mem::transmute_copy(&options), ::core::mem::transmute(&rootfolder)) { @@ -13827,12 +13815,12 @@ impl IShellDispatch_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Open, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Open, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Open(::core::mem::transmute(&vdir)).into() } - unsafe extern "system" fn Explore, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Explore, Impl: IShellDispatch_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Explore(::core::mem::transmute(&vdir)).into() @@ -13948,22 +13936,22 @@ impl IShellDispatch_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch2_Impl: Sized + IShellDispatch_Impl { fn IsRestricted(&self, group: &::windows_core::BSTR, restriction: &::windows_core::BSTR) -> ::windows_core::Result; - fn ShellExecute(&self, file: &::windows_core::BSTR, vargs: &super::super::System::Variant::VARIANT, vdir: &super::super::System::Variant::VARIANT, voperation: &super::super::System::Variant::VARIANT, vshow: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ShellExecute(&self, file: &::windows_core::BSTR, vargs: &::windows_core::VARIANT, vdir: &::windows_core::VARIANT, voperation: &::windows_core::VARIANT, vshow: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn FindPrinter(&self, name: &::windows_core::BSTR, location: &::windows_core::BSTR, model: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn GetSystemInformation(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; - fn ServiceStart(&self, servicename: &::windows_core::BSTR, persistent: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn ServiceStop(&self, servicename: &::windows_core::BSTR, persistent: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn IsServiceRunning(&self, servicename: &::windows_core::BSTR) -> ::windows_core::Result; - fn CanStartStopService(&self, servicename: &::windows_core::BSTR) -> ::windows_core::Result; - fn ShowBrowserBar(&self, bstrclsid: &::windows_core::BSTR, bshow: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; -} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + fn GetSystemInformation(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ServiceStart(&self, servicename: &::windows_core::BSTR, persistent: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ServiceStop(&self, servicename: &::windows_core::BSTR, persistent: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; + fn IsServiceRunning(&self, servicename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn CanStartStopService(&self, servicename: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn ShowBrowserBar(&self, bstrclsid: &::windows_core::BSTR, bshow: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; +} +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch2_Vtbl { pub const fn new, Impl: IShellDispatch2_Impl, const OFFSET: isize>() -> IShellDispatch2_Vtbl { unsafe extern "system" fn IsRestricted, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, group: ::std::mem::MaybeUninit<::windows_core::BSTR>, restriction: ::std::mem::MaybeUninit<::windows_core::BSTR>, plrestrictvalue: *mut i32) -> ::windows_core::HRESULT { @@ -13977,7 +13965,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ShellExecute, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, file: ::std::mem::MaybeUninit<::windows_core::BSTR>, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ShellExecute, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, file: ::std::mem::MaybeUninit<::windows_core::BSTR>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voperation: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vshow: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ShellExecute(::core::mem::transmute(&file), ::core::mem::transmute(&vargs), ::core::mem::transmute(&vdir), ::core::mem::transmute(&voperation), ::core::mem::transmute(&vshow)).into() @@ -13987,7 +13975,7 @@ impl IShellDispatch2_Vtbl { let this = (*this).get_impl(); this.FindPrinter(::core::mem::transmute(&name), ::core::mem::transmute(&location), ::core::mem::transmute(&model)).into() } - unsafe extern "system" fn GetSystemInformation, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetSystemInformation, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetSystemInformation(::core::mem::transmute(&name)) { @@ -13998,7 +13986,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ServiceStart, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ServiceStart, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ServiceStart(::core::mem::transmute(&servicename), ::core::mem::transmute(&persistent)) { @@ -14009,7 +13997,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ServiceStop, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ServiceStop, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ServiceStop(::core::mem::transmute(&servicename), ::core::mem::transmute(&persistent)) { @@ -14020,7 +14008,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn IsServiceRunning, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, prunning: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn IsServiceRunning, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, prunning: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.IsServiceRunning(::core::mem::transmute(&servicename)) { @@ -14031,7 +14019,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn CanStartStopService, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcanstartstop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CanStartStopService, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcanstartstop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CanStartStopService(::core::mem::transmute(&servicename)) { @@ -14042,7 +14030,7 @@ impl IShellDispatch2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ShowBrowserBar, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bshow: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ShowBrowserBar, Impl: IShellDispatch2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bshow: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ShowBrowserBar(::core::mem::transmute(&bstrclsid), ::core::mem::transmute(&bshow)) { @@ -14070,17 +14058,17 @@ impl IShellDispatch2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch3_Impl: Sized + IShellDispatch2_Impl { - fn AddToRecent(&self, varfile: &super::super::System::Variant::VARIANT, bstrcategory: &::windows_core::BSTR) -> ::windows_core::Result<()>; + fn AddToRecent(&self, varfile: &::windows_core::VARIANT, bstrcategory: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch3_Vtbl { pub const fn new, Impl: IShellDispatch3_Impl, const OFFSET: isize>() -> IShellDispatch3_Vtbl { - unsafe extern "system" fn AddToRecent, Impl: IShellDispatch3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varfile: super::super::System::Variant::VARIANT, bstrcategory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddToRecent, Impl: IShellDispatch3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varfile: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrcategory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddToRecent(::core::mem::transmute(&varfile), ::core::mem::transmute(&bstrcategory)).into() @@ -14091,17 +14079,17 @@ impl IShellDispatch3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch4_Impl: Sized + IShellDispatch3_Impl { fn WindowsSecurity(&self) -> ::windows_core::Result<()>; fn ToggleDesktop(&self) -> ::windows_core::Result<()>; - fn ExplorerPolicy(&self, bstrpolicyname: &::windows_core::BSTR) -> ::windows_core::Result; + fn ExplorerPolicy(&self, bstrpolicyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetSetting(&self, lsetting: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch4_Vtbl { pub const fn new, Impl: IShellDispatch4_Impl, const OFFSET: isize>() -> IShellDispatch4_Vtbl { unsafe extern "system" fn WindowsSecurity, Impl: IShellDispatch4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14114,7 +14102,7 @@ impl IShellDispatch4_Vtbl { let this = (*this).get_impl(); this.ToggleDesktop().into() } - unsafe extern "system" fn ExplorerPolicy, Impl: IShellDispatch4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpolicyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExplorerPolicy, Impl: IShellDispatch4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpolicyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ExplorerPolicy(::core::mem::transmute(&bstrpolicyname)) { @@ -14148,14 +14136,14 @@ impl IShellDispatch4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch5_Impl: Sized + IShellDispatch4_Impl { fn WindowSwitcher(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch5_Vtbl { pub const fn new, Impl: IShellDispatch5_Impl, const OFFSET: isize>() -> IShellDispatch5_Vtbl { unsafe extern "system" fn WindowSwitcher, Impl: IShellDispatch5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14169,14 +14157,14 @@ impl IShellDispatch5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellDispatch6_Impl: Sized + IShellDispatch5_Impl { fn SearchCommand(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellDispatch6 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellDispatch6_Vtbl { pub const fn new, Impl: IShellDispatch6_Impl, const OFFSET: isize>() -> IShellDispatch6_Vtbl { unsafe extern "system" fn SearchCommand, Impl: IShellDispatch6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14211,8 +14199,8 @@ impl IShellExtInit_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellFavoritesNameSpace_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn MoveSelectionUp(&self) -> ::windows_core::Result<()>; fn MoveSelectionDown(&self) -> ::windows_core::Result<()>; @@ -14228,9 +14216,9 @@ pub trait IShellFavoritesNameSpace_Impl: Sized + super::super::System::Com::IDis fn DeleteSubscriptionForSelection(&self) -> ::windows_core::Result; fn SetRoot(&self, bstrfullpath: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellFavoritesNameSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellFavoritesNameSpace_Vtbl { pub const fn new, Impl: IShellFavoritesNameSpace_Impl, const OFFSET: isize>() -> IShellFavoritesNameSpace_Vtbl { unsafe extern "system" fn MoveSelectionUp, Impl: IShellFavoritesNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14424,20 +14412,20 @@ impl IShellFolder_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IShellFolder2_Impl: Sized + IShellFolder_Impl { fn GetDefaultSearchGUID(&self) -> ::windows_core::Result<::windows_core::GUID>; fn EnumSearches(&self) -> ::windows_core::Result; fn GetDefaultColumn(&self, dwres: u32, psort: *mut u32, pdisplay: *mut u32) -> ::windows_core::Result<()>; fn GetDefaultColumnState(&self, icolumn: u32) -> ::windows_core::Result; - fn GetDetailsEx(&self, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetDetailsEx(&self, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetDetailsOf(&self, pidl: *const Common::ITEMIDLIST, icolumn: u32, psd: *mut Common::SHELLDETAILS) -> ::windows_core::Result<()>; fn MapColumnToSCID(&self, icolumn: u32, pscid: *mut PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IShellFolder2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IShellFolder2_Vtbl { pub const fn new, Impl: IShellFolder2_Impl, const OFFSET: isize>() -> IShellFolder2_Vtbl { unsafe extern "system" fn GetDefaultSearchGUID, Impl: IShellFolder2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -14478,7 +14466,7 @@ impl IShellFolder2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetDetailsEx, Impl: IShellFolder2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetDetailsEx, Impl: IShellFolder2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetDetailsEx(::core::mem::transmute_copy(&pidl), ::core::mem::transmute_copy(&pscid)) { @@ -14848,22 +14836,22 @@ impl IShellFolderViewCB_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellFolderViewDual_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; fn Folder(&self) -> ::windows_core::Result; fn SelectedItems(&self) -> ::windows_core::Result; fn FocusedItem(&self) -> ::windows_core::Result; - fn SelectItem(&self, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::Result<()>; - fn PopupItemMenu(&self, pfi: ::core::option::Option<&FolderItem>, vx: &super::super::System::Variant::VARIANT, vy: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; + fn SelectItem(&self, pvfi: *const ::windows_core::VARIANT, dwflags: i32) -> ::windows_core::Result<()>; + fn PopupItemMenu(&self, pfi: ::core::option::Option<&FolderItem>, vx: &::windows_core::VARIANT, vy: &::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::BSTR>; fn Script(&self) -> ::windows_core::Result; fn ViewOptions(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellFolderViewDual {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellFolderViewDual_Vtbl { pub const fn new, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>() -> IShellFolderViewDual_Vtbl { unsafe extern "system" fn Application, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -14921,12 +14909,12 @@ impl IShellFolderViewDual_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SelectItem, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelectItem, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvfi: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwflags: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SelectItem(::core::mem::transmute_copy(&pvfi), ::core::mem::transmute_copy(&dwflags)).into() } - unsafe extern "system" fn PopupItemMenu, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfi: *mut ::core::ffi::c_void, vx: super::super::System::Variant::VARIANT, vy: super::super::System::Variant::VARIANT, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { + unsafe extern "system" fn PopupItemMenu, Impl: IShellFolderViewDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfi: *mut ::core::ffi::c_void, vx: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vy: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PopupItemMenu(::windows_core::from_raw_borrowed(&pfi), ::core::mem::transmute(&vx), ::core::mem::transmute(&vy)) { @@ -14976,16 +14964,16 @@ impl IShellFolderViewDual_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellFolderViewDual2_Impl: Sized + IShellFolderViewDual_Impl { fn CurrentViewMode(&self) -> ::windows_core::Result; fn SetCurrentViewMode(&self, viewmode: u32) -> ::windows_core::Result<()>; fn SelectItemRelative(&self, irelative: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellFolderViewDual2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellFolderViewDual2_Vtbl { pub const fn new, Impl: IShellFolderViewDual2_Impl, const OFFSET: isize>() -> IShellFolderViewDual2_Vtbl { unsafe extern "system" fn CurrentViewMode, Impl: IShellFolderViewDual2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pviewmode: *mut u32) -> ::windows_core::HRESULT { @@ -15020,8 +15008,8 @@ impl IShellFolderViewDual2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellFolderViewDual3_Impl: Sized + IShellFolderViewDual2_Impl { fn GroupBy(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetGroupBy(&self, bstrgroupby: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -15033,9 +15021,9 @@ pub trait IShellFolderViewDual3_Impl: Sized + IShellFolderViewDual2_Impl { fn IconSize(&self) -> ::windows_core::Result; fn FilterView(&self, bstrfiltertext: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellFolderViewDual3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellFolderViewDual3_Vtbl { pub const fn new, Impl: IShellFolderViewDual3_Impl, const OFFSET: isize>() -> IShellFolderViewDual3_Vtbl { unsafe extern "system" fn GroupBy, Impl: IShellFolderViewDual3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrgroupby: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -15671,15 +15659,15 @@ impl IShellItem_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_SystemServices\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_SystemServices", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_SystemServices\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_SystemServices", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait IShellItem2_Impl: Sized + IShellItem_Impl { fn GetPropertyStore(&self, flags: PropertiesSystem::GETPROPERTYSTOREFLAGS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetPropertyStoreWithCreateObject(&self, flags: PropertiesSystem::GETPROPERTYSTOREFLAGS, punkcreateobject: ::core::option::Option<&::windows_core::IUnknown>, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetPropertyStoreForKeys(&self, rgkeys: *const PropertiesSystem::PROPERTYKEY, ckeys: u32, flags: PropertiesSystem::GETPROPERTYSTOREFLAGS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn GetPropertyDescriptionList(&self, keytype: *const PropertiesSystem::PROPERTYKEY, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; fn Update(&self, pbc: ::core::option::Option<&super::super::System::Com::IBindCtx>) -> ::windows_core::Result<()>; - fn GetProperty(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetProperty(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetCLSID(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::GUID>; fn GetFileTime(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; fn GetInt32(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; @@ -15688,9 +15676,9 @@ pub trait IShellItem2_Impl: Sized + IShellItem_Impl { fn GetUInt64(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; fn GetBool(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_SystemServices", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_SystemServices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for IShellItem2 {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_SystemServices", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_SystemServices", feature = "Win32_UI_Shell_PropertiesSystem"))] impl IShellItem2_Vtbl { pub const fn new, Impl: IShellItem2_Impl, const OFFSET: isize>() -> IShellItem2_Vtbl { unsafe extern "system" fn GetPropertyStore, Impl: IShellItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, flags: PropertiesSystem::GETPROPERTYSTOREFLAGS, riid: *const ::windows_core::GUID, ppv: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -15718,7 +15706,7 @@ impl IShellItem2_Vtbl { let this = (*this).get_impl(); this.Update(::windows_core::from_raw_borrowed(&pbc)).into() } - unsafe extern "system" fn GetProperty, Impl: IShellItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IShellItem2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&key)) { @@ -16461,8 +16449,8 @@ impl IShellLinkDataList_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellLinkDual_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Path(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetPath(&self, bs: &::windows_core::BSTR) -> ::windows_core::Result<()>; @@ -16479,11 +16467,11 @@ pub trait IShellLinkDual_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Resolve(&self, fflags: i32) -> ::windows_core::Result<()>; fn GetIconLocation(&self, pbs: *mut ::windows_core::BSTR, piicon: *mut i32) -> ::windows_core::Result<()>; fn SetIconLocation(&self, bs: &::windows_core::BSTR, iicon: i32) -> ::windows_core::Result<()>; - fn Save(&self, vwhere: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Save(&self, vwhere: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellLinkDual {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellLinkDual_Vtbl { pub const fn new, Impl: IShellLinkDual_Impl, const OFFSET: isize>() -> IShellLinkDual_Vtbl { unsafe extern "system" fn Path, Impl: IShellLinkDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -16597,7 +16585,7 @@ impl IShellLinkDual_Vtbl { let this = (*this).get_impl(); this.SetIconLocation(::core::mem::transmute(&bs), ::core::mem::transmute_copy(&iicon)).into() } - unsafe extern "system" fn Save, Impl: IShellLinkDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vwhere: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Save, Impl: IShellLinkDual_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vwhere: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Save(::core::mem::transmute(&vwhere)).into() @@ -16626,14 +16614,14 @@ impl IShellLinkDual_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellLinkDual2_Impl: Sized + IShellLinkDual_Impl { fn Target(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellLinkDual2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellLinkDual2_Vtbl { pub const fn new, Impl: IShellLinkDual2_Impl, const OFFSET: isize>() -> IShellLinkDual2_Vtbl { unsafe extern "system" fn Target, Impl: IShellLinkDual2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppfi: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -16915,15 +16903,15 @@ impl IShellMenuCallback_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellNameSpace_Impl: Sized + IShellFavoritesNameSpace_Impl { fn EnumOptions(&self) -> ::windows_core::Result; fn SetEnumOptions(&self, lval: i32) -> ::windows_core::Result<()>; fn SelectedItem(&self) -> ::windows_core::Result; fn SetSelectedItem(&self, pitem: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; - fn Root(&self) -> ::windows_core::Result; - fn SetRoot2(&self, var: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Root(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetRoot2(&self, var: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Depth(&self) -> ::windows_core::Result; fn SetDepth(&self, idepth: i32) -> ::windows_core::Result<()>; fn Mode(&self) -> ::windows_core::Result; @@ -16937,12 +16925,12 @@ pub trait IShellNameSpace_Impl: Sized + IShellFavoritesNameSpace_Impl { fn CountViewTypes(&self) -> ::windows_core::Result; fn SetViewType(&self, itype: i32) -> ::windows_core::Result<()>; fn SelectedItems(&self) -> ::windows_core::Result; - fn Expand(&self, var: &super::super::System::Variant::VARIANT, idepth: i32) -> ::windows_core::Result<()>; + fn Expand(&self, var: &::windows_core::VARIANT, idepth: i32) -> ::windows_core::Result<()>; fn UnselectAll(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellNameSpace {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellNameSpace_Vtbl { pub const fn new, Impl: IShellNameSpace_Impl, const OFFSET: isize>() -> IShellNameSpace_Vtbl { unsafe extern "system" fn EnumOptions, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pgrfenumflags: *mut i32) -> ::windows_core::HRESULT { @@ -16977,7 +16965,7 @@ impl IShellNameSpace_Vtbl { let this = (*this).get_impl(); this.SetSelectedItem(::windows_core::from_raw_borrowed(&pitem)).into() } - unsafe extern "system" fn Root, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Root, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Root() { @@ -16988,7 +16976,7 @@ impl IShellNameSpace_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetRoot2, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetRoot2, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetRoot2(::core::mem::transmute(&var)).into() @@ -17100,7 +17088,7 @@ impl IShellNameSpace_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Expand, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT, idepth: i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Expand, Impl: IShellNameSpace_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>, idepth: i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Expand(::core::mem::transmute(&var), ::core::mem::transmute_copy(&idepth)).into() @@ -17245,26 +17233,26 @@ impl IShellTaskScheduler_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ResetFirstBootMode(&self) -> ::windows_core::Result<()>; fn ResetSafeMode(&self) -> ::windows_core::Result<()>; fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()>; - fn AddFavorite(&self, url: &::windows_core::BSTR, title: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddFavorite(&self, url: &::windows_core::BSTR, title: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn AddChannel(&self, url: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AddDesktopComponent(&self, url: &::windows_core::BSTR, r#type: &::windows_core::BSTR, left: *const super::super::System::Variant::VARIANT, top: *const super::super::System::Variant::VARIANT, width: *const super::super::System::Variant::VARIANT, height: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddDesktopComponent(&self, url: &::windows_core::BSTR, r#type: &::windows_core::BSTR, left: *const ::windows_core::VARIANT, top: *const ::windows_core::VARIANT, width: *const ::windows_core::VARIANT, height: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn IsSubscribed(&self, url: &::windows_core::BSTR) -> ::windows_core::Result; - fn NavigateAndFind(&self, url: &::windows_core::BSTR, strquery: &::windows_core::BSTR, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn NavigateAndFind(&self, url: &::windows_core::BSTR, strquery: &::windows_core::BSTR, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ImportExportFavorites(&self, fimport: super::super::Foundation::VARIANT_BOOL, strimpexppath: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn AutoCompleteSaveForm(&self, form: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AutoScan(&self, strsearch: &::windows_core::BSTR, strfailureurl: &::windows_core::BSTR, pvartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn AutoCompleteAttach(&self, reserved: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ShowBrowserUI(&self, bstrname: &::windows_core::BSTR, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn AutoCompleteSaveForm(&self, form: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AutoScan(&self, strsearch: &::windows_core::BSTR, strfailureurl: &::windows_core::BSTR, pvartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn AutoCompleteAttach(&self, reserved: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ShowBrowserUI(&self, bstrname: &::windows_core::BSTR, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper_Vtbl { pub const fn new, Impl: IShellUIHelper_Impl, const OFFSET: isize>() -> IShellUIHelper_Vtbl { unsafe extern "system" fn ResetFirstBootMode, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17282,7 +17270,7 @@ impl IShellUIHelper_Vtbl { let this = (*this).get_impl(); this.RefreshOfflineDesktop().into() } - unsafe extern "system" fn AddFavorite, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddFavorite, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddFavorite(::core::mem::transmute(&url), ::core::mem::transmute_copy(&title)).into() @@ -17292,7 +17280,7 @@ impl IShellUIHelper_Vtbl { let this = (*this).get_impl(); this.AddChannel(::core::mem::transmute(&url)).into() } - unsafe extern "system" fn AddDesktopComponent, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: ::std::mem::MaybeUninit<::windows_core::BSTR>, left: *const super::super::System::Variant::VARIANT, top: *const super::super::System::Variant::VARIANT, width: *const super::super::System::Variant::VARIANT, height: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddDesktopComponent, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: ::std::mem::MaybeUninit<::windows_core::BSTR>, left: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, top: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, width: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, height: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddDesktopComponent(::core::mem::transmute(&url), ::core::mem::transmute(&r#type), ::core::mem::transmute_copy(&left), ::core::mem::transmute_copy(&top), ::core::mem::transmute_copy(&width), ::core::mem::transmute_copy(&height)).into() @@ -17308,7 +17296,7 @@ impl IShellUIHelper_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn NavigateAndFind, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, strquery: ::std::mem::MaybeUninit<::windows_core::BSTR>, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn NavigateAndFind, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, strquery: ::std::mem::MaybeUninit<::windows_core::BSTR>, vartargetframe: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.NavigateAndFind(::core::mem::transmute(&url), ::core::mem::transmute(&strquery), ::core::mem::transmute_copy(&vartargetframe)).into() @@ -17318,22 +17306,22 @@ impl IShellUIHelper_Vtbl { let this = (*this).get_impl(); this.ImportExportFavorites(::core::mem::transmute_copy(&fimport), ::core::mem::transmute(&strimpexppath)).into() } - unsafe extern "system" fn AutoCompleteSaveForm, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, form: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AutoCompleteSaveForm, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, form: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AutoCompleteSaveForm(::core::mem::transmute_copy(&form)).into() } - unsafe extern "system" fn AutoScan, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strsearch: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfailureurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AutoScan, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strsearch: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfailureurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvartargetframe: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AutoScan(::core::mem::transmute(&strsearch), ::core::mem::transmute(&strfailureurl), ::core::mem::transmute_copy(&pvartargetframe)).into() } - unsafe extern "system" fn AutoCompleteAttach, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reserved: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AutoCompleteAttach, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, reserved: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AutoCompleteAttach(::core::mem::transmute_copy(&reserved)).into() } - unsafe extern "system" fn ShowBrowserUI, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarin: *const super::super::System::Variant::VARIANT, pvarout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ShowBrowserUI, Impl: IShellUIHelper_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.ShowBrowserUI(::core::mem::transmute(&bstrname), ::core::mem::transmute_copy(&pvarin)) { @@ -17365,8 +17353,8 @@ impl IShellUIHelper_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper2_Impl: Sized + IShellUIHelper_Impl { fn AddSearchProvider(&self, url: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RunOnceShown(&self) -> ::windows_core::Result<()>; @@ -17385,9 +17373,9 @@ pub trait IShellUIHelper2_Impl: Sized + IShellUIHelper_Impl { fn RunOnceHasShown(&self) -> ::windows_core::Result; fn SearchGuideUrl(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper2_Vtbl { pub const fn new, Impl: IShellUIHelper2_Impl, const OFFSET: isize>() -> IShellUIHelper2_Vtbl { unsafe extern "system" fn AddSearchProvider, Impl: IShellUIHelper2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -17542,13 +17530,13 @@ impl IShellUIHelper2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper3_Impl: Sized + IShellUIHelper2_Impl { fn AddService(&self, url: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn IsServiceInstalled(&self, url: &::windows_core::BSTR, verb: &::windows_core::BSTR) -> ::windows_core::Result; fn InPrivateFilteringEnabled(&self) -> ::windows_core::Result; - fn AddToFavoritesBar(&self, url: &::windows_core::BSTR, title: &::windows_core::BSTR, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn AddToFavoritesBar(&self, url: &::windows_core::BSTR, title: &::windows_core::BSTR, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn BuildNewTabPage(&self) -> ::windows_core::Result<()>; fn SetRecentlyClosedVisible(&self, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetActivitiesVisible(&self, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -17559,9 +17547,9 @@ pub trait IShellUIHelper3_Impl: Sized + IShellUIHelper2_Impl { fn ShowTabsHelp(&self) -> ::windows_core::Result<()>; fn ShowInPrivateHelp(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper3_Vtbl { pub const fn new, Impl: IShellUIHelper3_Impl, const OFFSET: isize>() -> IShellUIHelper3_Vtbl { unsafe extern "system" fn AddService, Impl: IShellUIHelper3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -17591,7 +17579,7 @@ impl IShellUIHelper3_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn AddToFavoritesBar, Impl: IShellUIHelper3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn AddToFavoritesBar, Impl: IShellUIHelper3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.AddToFavoritesBar(::core::mem::transmute(&url), ::core::mem::transmute(&title), ::core::mem::transmute_copy(&r#type)).into() @@ -17668,31 +17656,31 @@ impl IShellUIHelper3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper4_Impl: Sized + IShellUIHelper3_Impl { fn msIsSiteMode(&self) -> ::windows_core::Result; fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()>; - fn msSiteModeAddThumbBarButton(&self, bstriconurl: &::windows_core::BSTR, bstrtooltip: &::windows_core::BSTR) -> ::windows_core::Result; - fn msSiteModeUpdateThumbBarButton(&self, buttonid: &super::super::System::Variant::VARIANT, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn msSiteModeSetIconOverlay(&self, iconurl: &::windows_core::BSTR, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msSiteModeAddThumbBarButton(&self, bstriconurl: &::windows_core::BSTR, bstrtooltip: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn msSiteModeUpdateThumbBarButton(&self, buttonid: &::windows_core::VARIANT, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; + fn msSiteModeSetIconOverlay(&self, iconurl: &::windows_core::BSTR, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()>; fn msAddSiteMode(&self) -> ::windows_core::Result<()>; fn msSiteModeCreateJumpList(&self, bstrheader: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn msSiteModeAddJumpListItem(&self, bstrname: &::windows_core::BSTR, bstractionuri: &::windows_core::BSTR, bstriconuri: &::windows_core::BSTR, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msSiteModeAddJumpListItem(&self, bstrname: &::windows_core::BSTR, bstractionuri: &::windows_core::BSTR, bstriconuri: &::windows_core::BSTR, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()>; fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()>; - fn msSiteModeAddButtonStyle(&self, uibuttonid: &super::super::System::Variant::VARIANT, bstriconurl: &::windows_core::BSTR, bstrtooltip: &::windows_core::BSTR) -> ::windows_core::Result; - fn msSiteModeShowButtonStyle(&self, uibuttonid: &super::super::System::Variant::VARIANT, uistyleid: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msSiteModeAddButtonStyle(&self, uibuttonid: &::windows_core::VARIANT, bstriconurl: &::windows_core::BSTR, bstrtooltip: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn msSiteModeShowButtonStyle(&self, uibuttonid: &::windows_core::VARIANT, uistyleid: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msSiteModeActivate(&self) -> ::windows_core::Result<()>; - fn msIsSiteModeFirstRun(&self, fpreservestate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result; + fn msIsSiteModeFirstRun(&self, fpreservestate: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<::windows_core::VARIANT>; fn msAddTrackingProtectionList(&self, url: &::windows_core::BSTR, bstrfiltername: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn msTrackingProtectionEnabled(&self) -> ::windows_core::Result; fn msActiveXFilteringEnabled(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper4 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper4_Vtbl { pub const fn new, Impl: IShellUIHelper4_Impl, const OFFSET: isize>() -> IShellUIHelper4_Vtbl { unsafe extern "system" fn msIsSiteMode, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pfsitemode: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -17711,7 +17699,7 @@ impl IShellUIHelper4_Vtbl { let this = (*this).get_impl(); this.msSiteModeShowThumbBar().into() } - unsafe extern "system" fn msSiteModeAddThumbBarButton, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbuttonid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeAddThumbBarButton, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbuttonid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.msSiteModeAddThumbBarButton(::core::mem::transmute(&bstriconurl), ::core::mem::transmute(&bstrtooltip)) { @@ -17722,12 +17710,12 @@ impl IShellUIHelper4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn msSiteModeUpdateThumbBarButton, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buttonid: super::super::System::Variant::VARIANT, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeUpdateThumbBarButton, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, buttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msSiteModeUpdateThumbBarButton(::core::mem::transmute(&buttonid), ::core::mem::transmute_copy(&fenabled), ::core::mem::transmute_copy(&fvisible)).into() } - unsafe extern "system" fn msSiteModeSetIconOverlay, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeSetIconOverlay, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, iconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardescription: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msSiteModeSetIconOverlay(::core::mem::transmute(&iconurl), ::core::mem::transmute_copy(&pvardescription)).into() @@ -17747,7 +17735,7 @@ impl IShellUIHelper4_Vtbl { let this = (*this).get_impl(); this.msSiteModeCreateJumpList(::core::mem::transmute(&bstrheader)).into() } - unsafe extern "system" fn msSiteModeAddJumpListItem, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstractionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstriconuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeAddJumpListItem, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstractionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstriconuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarwindowtype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msSiteModeAddJumpListItem(::core::mem::transmute(&bstrname), ::core::mem::transmute(&bstractionuri), ::core::mem::transmute(&bstriconuri), ::core::mem::transmute_copy(&pvarwindowtype)).into() @@ -17762,7 +17750,7 @@ impl IShellUIHelper4_Vtbl { let this = (*this).get_impl(); this.msSiteModeShowJumpList().into() } - unsafe extern "system" fn msSiteModeAddButtonStyle, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarstyleid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeAddButtonStyle, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uibuttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarstyleid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.msSiteModeAddButtonStyle(::core::mem::transmute(&uibuttonid), ::core::mem::transmute(&bstriconurl), ::core::mem::transmute(&bstrtooltip)) { @@ -17773,7 +17761,7 @@ impl IShellUIHelper4_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn msSiteModeShowButtonStyle, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msSiteModeShowButtonStyle, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, uibuttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uistyleid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msSiteModeShowButtonStyle(::core::mem::transmute(&uibuttonid), ::core::mem::transmute(&uistyleid)).into() @@ -17783,7 +17771,7 @@ impl IShellUIHelper4_Vtbl { let this = (*this).get_impl(); this.msSiteModeActivate().into() } - unsafe extern "system" fn msIsSiteModeFirstRun, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fpreservestate: super::super::Foundation::VARIANT_BOOL, puifirstrun: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msIsSiteModeFirstRun, Impl: IShellUIHelper4_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fpreservestate: super::super::Foundation::VARIANT_BOOL, puifirstrun: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.msIsSiteModeFirstRun(::core::mem::transmute_copy(&fpreservestate)) { @@ -17847,10 +17835,10 @@ impl IShellUIHelper4_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper5_Impl: Sized + IShellUIHelper4_Impl { - fn msProvisionNetworks(&self, bstrprovisioningxml: &::windows_core::BSTR) -> ::windows_core::Result; + fn msProvisionNetworks(&self, bstrprovisioningxml: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn msReportSafeUrl(&self) -> ::windows_core::Result<()>; fn msSiteModeRefreshBadge(&self) -> ::windows_core::Result<()>; fn msSiteModeClearBadge(&self) -> ::windows_core::Result<()>; @@ -17858,12 +17846,12 @@ pub trait IShellUIHelper5_Impl: Sized + IShellUIHelper4_Impl { fn msLaunchNetworkClientHelp(&self) -> ::windows_core::Result<()>; fn msChangeDefaultBrowser(&self, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper5 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper5_Vtbl { pub const fn new, Impl: IShellUIHelper5_Impl, const OFFSET: isize>() -> IShellUIHelper5_Vtbl { - unsafe extern "system" fn msProvisionNetworks, Impl: IShellUIHelper5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovisioningxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, puiresult: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msProvisionNetworks, Impl: IShellUIHelper5_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrprovisioningxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, puiresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.msProvisionNetworks(::core::mem::transmute(&bstrprovisioningxml)) { @@ -17919,27 +17907,27 @@ impl IShellUIHelper5_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper6_Impl: Sized + IShellUIHelper5_Impl { fn msStopPeriodicTileUpdate(&self) -> ::windows_core::Result<()>; - fn msStartPeriodicTileUpdate(&self, pollinguris: &super::super::System::Variant::VARIANT, starttime: &super::super::System::Variant::VARIANT, uiupdaterecurrence: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn msStartPeriodicTileUpdateBatch(&self, pollinguris: &super::super::System::Variant::VARIANT, starttime: &super::super::System::Variant::VARIANT, uiupdaterecurrence: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msStartPeriodicTileUpdate(&self, pollinguris: &::windows_core::VARIANT, starttime: &::windows_core::VARIANT, uiupdaterecurrence: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn msStartPeriodicTileUpdateBatch(&self, pollinguris: &::windows_core::VARIANT, starttime: &::windows_core::VARIANT, uiupdaterecurrence: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msClearTile(&self) -> ::windows_core::Result<()>; fn msEnableTileNotificationQueue(&self, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn msPinnedSiteState(&self) -> ::windows_core::Result; + fn msPinnedSiteState(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn msEnableTileNotificationQueueForSquare150x150(&self, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn msEnableTileNotificationQueueForWide310x150(&self, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn msEnableTileNotificationQueueForSquare310x310(&self, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn msScheduledTileNotification(&self, bstrnotificationxml: &::windows_core::BSTR, bstrnotificationid: &::windows_core::BSTR, bstrnotificationtag: &::windows_core::BSTR, starttime: &super::super::System::Variant::VARIANT, expirationtime: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msScheduledTileNotification(&self, bstrnotificationxml: &::windows_core::BSTR, bstrnotificationid: &::windows_core::BSTR, bstrnotificationtag: &::windows_core::BSTR, starttime: &::windows_core::VARIANT, expirationtime: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msRemoveScheduledTileNotification(&self, bstrnotificationid: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn msStartPeriodicBadgeUpdate(&self, pollinguri: &::windows_core::BSTR, starttime: &super::super::System::Variant::VARIANT, uiupdaterecurrence: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn msStartPeriodicBadgeUpdate(&self, pollinguri: &::windows_core::BSTR, starttime: &::windows_core::VARIANT, uiupdaterecurrence: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn msStopPeriodicBadgeUpdate(&self) -> ::windows_core::Result<()>; fn msLaunchInternetOptions(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper6 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper6_Vtbl { pub const fn new, Impl: IShellUIHelper6_Impl, const OFFSET: isize>() -> IShellUIHelper6_Vtbl { unsafe extern "system" fn msStopPeriodicTileUpdate, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -17947,12 +17935,12 @@ impl IShellUIHelper6_Vtbl { let this = (*this).get_impl(); this.msStopPeriodicTileUpdate().into() } - unsafe extern "system" fn msStartPeriodicTileUpdate, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msStartPeriodicTileUpdate, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguris: ::std::mem::MaybeUninit<::windows_core::VARIANT>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msStartPeriodicTileUpdate(::core::mem::transmute(&pollinguris), ::core::mem::transmute(&starttime), ::core::mem::transmute(&uiupdaterecurrence)).into() } - unsafe extern "system" fn msStartPeriodicTileUpdateBatch, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msStartPeriodicTileUpdateBatch, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguris: ::std::mem::MaybeUninit<::windows_core::VARIANT>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msStartPeriodicTileUpdateBatch(::core::mem::transmute(&pollinguris), ::core::mem::transmute(&starttime), ::core::mem::transmute(&uiupdaterecurrence)).into() @@ -17967,7 +17955,7 @@ impl IShellUIHelper6_Vtbl { let this = (*this).get_impl(); this.msEnableTileNotificationQueue(::core::mem::transmute_copy(&fchange)).into() } - unsafe extern "system" fn msPinnedSiteState, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsitestate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msPinnedSiteState, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarsitestate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.msPinnedSiteState() { @@ -17993,7 +17981,7 @@ impl IShellUIHelper6_Vtbl { let this = (*this).get_impl(); this.msEnableTileNotificationQueueForSquare310x310(::core::mem::transmute_copy(&fchange)).into() } - unsafe extern "system" fn msScheduledTileNotification, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrnotificationxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationtag: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msScheduledTileNotification, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrnotificationxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationtag: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, expirationtime: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msScheduledTileNotification(::core::mem::transmute(&bstrnotificationxml), ::core::mem::transmute(&bstrnotificationid), ::core::mem::transmute(&bstrnotificationtag), ::core::mem::transmute(&starttime), ::core::mem::transmute(&expirationtime)).into() @@ -18003,7 +17991,7 @@ impl IShellUIHelper6_Vtbl { let this = (*this).get_impl(); this.msRemoveScheduledTileNotification(::core::mem::transmute(&bstrnotificationid)).into() } - unsafe extern "system" fn msStartPeriodicBadgeUpdate, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguri: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn msStartPeriodicBadgeUpdate, Impl: IShellUIHelper6_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pollinguri: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.msStartPeriodicBadgeUpdate(::core::mem::transmute(&pollinguri), ::core::mem::transmute(&starttime), ::core::mem::transmute(&uiupdaterecurrence)).into() @@ -18040,8 +18028,8 @@ impl IShellUIHelper6_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper7_Impl: Sized + IShellUIHelper6_Impl { fn SetExperimentalFlag(&self, bstrflagstring: &::windows_core::BSTR, vfflag: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn GetExperimentalFlag(&self, bstrflagstring: &::windows_core::BSTR) -> ::windows_core::Result; @@ -18053,9 +18041,9 @@ pub trait IShellUIHelper7_Impl: Sized + IShellUIHelper6_Impl { fn HasNeedIEAutoLaunchFlag(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result; fn LaunchIE(&self, bstrurl: &::windows_core::BSTR, automated: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper7 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper7_Vtbl { pub const fn new, Impl: IShellUIHelper7_Impl, const OFFSET: isize>() -> IShellUIHelper7_Vtbl { unsafe extern "system" fn SetExperimentalFlag, Impl: IShellUIHelper7_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrflagstring: ::std::mem::MaybeUninit<::windows_core::BSTR>, vfflag: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -18144,8 +18132,8 @@ impl IShellUIHelper7_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper8_Impl: Sized + IShellUIHelper7_Impl { fn GetCVListData(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn GetCVListLocalData(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -18155,9 +18143,9 @@ pub trait IShellUIHelper8_Impl: Sized + IShellUIHelper7_Impl { fn OpenFavoritesSettings(&self) -> ::windows_core::Result<()>; fn LaunchInHVSI(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper8 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper8_Vtbl { pub const fn new, Impl: IShellUIHelper8_Impl, const OFFSET: isize>() -> IShellUIHelper8_Vtbl { unsafe extern "system" fn GetCVListData, Impl: IShellUIHelper8_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrresult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -18234,14 +18222,14 @@ impl IShellUIHelper8_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellUIHelper9_Impl: Sized + IShellUIHelper8_Impl { fn GetOSSku(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellUIHelper9 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellUIHelper9_Vtbl { pub const fn new, Impl: IShellUIHelper9_Impl, const OFFSET: isize>() -> IShellUIHelper9_Vtbl { unsafe extern "system" fn GetOSSku, Impl: IShellUIHelper9_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pdwresult: *mut u32) -> ::windows_core::HRESULT { @@ -18439,24 +18427,24 @@ impl IShellView3_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IShellWindows_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; - fn Item(&self, index: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, index: &::windows_core::VARIANT) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Register(&self, pid: ::core::option::Option<&super::super::System::Com::IDispatch>, hwnd: i32, swclass: ShellWindowTypeConstants) -> ::windows_core::Result; - fn RegisterPending(&self, lthreadid: i32, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants) -> ::windows_core::Result; + fn RegisterPending(&self, lthreadid: i32, pvarloc: *const ::windows_core::VARIANT, pvarlocroot: *const ::windows_core::VARIANT, swclass: ShellWindowTypeConstants) -> ::windows_core::Result; fn Revoke(&self, lcookie: i32) -> ::windows_core::Result<()>; - fn OnNavigate(&self, lcookie: i32, pvarloc: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OnNavigate(&self, lcookie: i32, pvarloc: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn OnActivated(&self, lcookie: i32, factive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn FindWindowSW(&self, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn FindWindowSW(&self, pvarloc: *const ::windows_core::VARIANT, pvarlocroot: *const ::windows_core::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn OnCreated(&self, lcookie: i32, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; fn ProcessAttachDetach(&self, fattach: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IShellWindows {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IShellWindows_Vtbl { pub const fn new, Impl: IShellWindows_Impl, const OFFSET: isize>() -> IShellWindows_Vtbl { unsafe extern "system" fn Count, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -18470,7 +18458,7 @@ impl IShellWindows_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, folder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, folder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&index)) { @@ -18503,7 +18491,7 @@ impl IShellWindows_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn RegisterPending, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lthreadid: i32, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, plcookie: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn RegisterPending, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lthreadid: i32, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarlocroot: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, swclass: ShellWindowTypeConstants, plcookie: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.RegisterPending(::core::mem::transmute_copy(<hreadid), ::core::mem::transmute_copy(&pvarloc), ::core::mem::transmute_copy(&pvarlocroot), ::core::mem::transmute_copy(&swclass)) { @@ -18519,7 +18507,7 @@ impl IShellWindows_Vtbl { let this = (*this).get_impl(); this.Revoke(::core::mem::transmute_copy(&lcookie)).into() } - unsafe extern "system" fn OnNavigate, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcookie: i32, pvarloc: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnNavigate, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, lcookie: i32, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnNavigate(::core::mem::transmute_copy(&lcookie), ::core::mem::transmute_copy(&pvarloc)).into() @@ -18529,7 +18517,7 @@ impl IShellWindows_Vtbl { let this = (*this).get_impl(); this.OnActivated(::core::mem::transmute_copy(&lcookie), ::core::mem::transmute_copy(&factive)).into() } - unsafe extern "system" fn FindWindowSW, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindWindowSW, Impl: IShellWindows_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarlocroot: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.FindWindowSW(::core::mem::transmute_copy(&pvarloc), ::core::mem::transmute_copy(&pvarlocroot), ::core::mem::transmute_copy(&swclass), ::core::mem::transmute_copy(&phwnd), ::core::mem::transmute_copy(&swfwoptions), ::core::mem::transmute_copy(&ppdispout)).into() @@ -18891,21 +18879,21 @@ impl ISuspensionDependencyManager_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] pub trait ISyncMgrConflict_Impl: Sized { - fn GetProperty(&self, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result; + fn GetProperty(&self, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT>; fn GetConflictIdInfo(&self) -> ::windows_core::Result; fn GetItemsArray(&self) -> ::windows_core::Result; fn Resolve(&self, presolveinfo: ::core::option::Option<&ISyncMgrConflictResolveInfo>) -> ::windows_core::Result<()>; fn GetResolutionHandler(&self, riid: *const ::windows_core::GUID, ppvresolutionhandler: *mut *mut ::core::ffi::c_void) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ::windows_core::RuntimeName for ISyncMgrConflict {} -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Shell_PropertiesSystem"))] impl ISyncMgrConflict_Vtbl { pub const fn new, Impl: ISyncMgrConflict_Impl, const OFFSET: isize>() -> ISyncMgrConflict_Vtbl { - unsafe extern "system" fn GetProperty, Impl: ISyncMgrConflict_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: ISyncMgrConflict_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute_copy(&propkey)) { @@ -22027,16 +22015,16 @@ impl IVisualProperties_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWebBrowser_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GoBack(&self) -> ::windows_core::Result<()>; fn GoForward(&self) -> ::windows_core::Result<()>; fn GoHome(&self) -> ::windows_core::Result<()>; fn GoSearch(&self) -> ::windows_core::Result<()>; - fn Navigate(&self, url: &::windows_core::BSTR, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Navigate(&self, url: &::windows_core::BSTR, flags: *const ::windows_core::VARIANT, targetframename: *const ::windows_core::VARIANT, postdata: *const ::windows_core::VARIANT, headers: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; - fn Refresh2(&self, level: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Refresh2(&self, level: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Stop(&self) -> ::windows_core::Result<()>; fn Application(&self) -> ::windows_core::Result; fn Parent(&self) -> ::windows_core::Result; @@ -22056,9 +22044,9 @@ pub trait IWebBrowser_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn LocationURL(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Busy(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWebBrowser {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWebBrowser_Vtbl { pub const fn new, Impl: IWebBrowser_Impl, const OFFSET: isize>() -> IWebBrowser_Vtbl { unsafe extern "system" fn GoBack, Impl: IWebBrowser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -22081,7 +22069,7 @@ impl IWebBrowser_Vtbl { let this = (*this).get_impl(); this.GoSearch().into() } - unsafe extern "system" fn Navigate, Impl: IWebBrowser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Navigate, Impl: IWebBrowser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, targetframename: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, postdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, headers: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Navigate(::core::mem::transmute(&url), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&targetframename), ::core::mem::transmute_copy(&postdata), ::core::mem::transmute_copy(&headers)).into() @@ -22091,7 +22079,7 @@ impl IWebBrowser_Vtbl { let this = (*this).get_impl(); this.Refresh().into() } - unsafe extern "system" fn Refresh2, Impl: IWebBrowser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, level: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Refresh2, Impl: IWebBrowser_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, level: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Refresh2(::core::mem::transmute_copy(&level)).into() @@ -22297,13 +22285,13 @@ impl IWebBrowser_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IWebBrowser2_Impl: Sized + IWebBrowserApp_Impl { - fn Navigate2(&self, url: *const super::super::System::Variant::VARIANT, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Navigate2(&self, url: *const ::windows_core::VARIANT, flags: *const ::windows_core::VARIANT, targetframename: *const ::windows_core::VARIANT, postdata: *const ::windows_core::VARIANT, headers: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn QueryStatusWB(&self, cmdid: super::super::System::Ole::OLECMDID) -> ::windows_core::Result; - fn ExecWB(&self, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const super::super::System::Variant::VARIANT, pvaout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn ShowBrowserBar(&self, pvaclsid: *const super::super::System::Variant::VARIANT, pvarshow: *const super::super::System::Variant::VARIANT, pvarsize: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn ExecWB(&self, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const ::windows_core::VARIANT, pvaout: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn ShowBrowserBar(&self, pvaclsid: *const ::windows_core::VARIANT, pvarshow: *const ::windows_core::VARIANT, pvarsize: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn ReadyState(&self) -> ::windows_core::Result; fn Offline(&self) -> ::windows_core::Result; fn SetOffline(&self, boffline: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -22320,12 +22308,12 @@ pub trait IWebBrowser2_Impl: Sized + IWebBrowserApp_Impl { fn Resizable(&self) -> ::windows_core::Result; fn SetResizable(&self, value: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IWebBrowser2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IWebBrowser2_Vtbl { pub const fn new, Impl: IWebBrowser2_Impl, const OFFSET: isize>() -> IWebBrowser2_Vtbl { - unsafe extern "system" fn Navigate2, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: *const super::super::System::Variant::VARIANT, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Navigate2, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, url: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, targetframename: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, postdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, headers: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Navigate2(::core::mem::transmute_copy(&url), ::core::mem::transmute_copy(&flags), ::core::mem::transmute_copy(&targetframename), ::core::mem::transmute_copy(&postdata), ::core::mem::transmute_copy(&headers)).into() @@ -22341,12 +22329,12 @@ impl IWebBrowser2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ExecWB, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const super::super::System::Variant::VARIANT, pvaout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ExecWB, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ExecWB(::core::mem::transmute_copy(&cmdid), ::core::mem::transmute_copy(&cmdexecopt), ::core::mem::transmute_copy(&pvain), ::core::mem::transmute_copy(&pvaout)).into() } - unsafe extern "system" fn ShowBrowserBar, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaclsid: *const super::super::System::Variant::VARIANT, pvarshow: *const super::super::System::Variant::VARIANT, pvarsize: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn ShowBrowserBar, Impl: IWebBrowser2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvaclsid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarshow: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarsize: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ShowBrowserBar(::core::mem::transmute_copy(&pvaclsid), ::core::mem::transmute_copy(&pvarshow), ::core::mem::transmute_copy(&pvarsize)).into() @@ -22501,13 +22489,13 @@ impl IWebBrowser2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWebBrowserApp_Impl: Sized + IWebBrowser_Impl { fn Quit(&self) -> ::windows_core::Result<()>; fn ClientToWindow(&self, pcx: *mut i32, pcy: *mut i32) -> ::windows_core::Result<()>; - fn PutProperty(&self, property: &::windows_core::BSTR, vtvalue: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetProperty(&self, property: &::windows_core::BSTR) -> ::windows_core::Result; + fn PutProperty(&self, property: &::windows_core::BSTR, vtvalue: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetProperty(&self, property: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn HWND(&self) -> ::windows_core::Result; fn FullName(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -22525,9 +22513,9 @@ pub trait IWebBrowserApp_Impl: Sized + IWebBrowser_Impl { fn FullScreen(&self) -> ::windows_core::Result; fn SetFullScreen(&self, bfullscreen: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWebBrowserApp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWebBrowserApp_Vtbl { pub const fn new, Impl: IWebBrowserApp_Impl, const OFFSET: isize>() -> IWebBrowserApp_Vtbl { unsafe extern "system" fn Quit, Impl: IWebBrowserApp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -22540,12 +22528,12 @@ impl IWebBrowserApp_Vtbl { let this = (*this).get_impl(); this.ClientToWindow(::core::mem::transmute_copy(&pcx), ::core::mem::transmute_copy(&pcy)).into() } - unsafe extern "system" fn PutProperty, Impl: IWebBrowserApp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PutProperty, Impl: IWebBrowserApp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PutProperty(::core::mem::transmute(&property), ::core::mem::transmute(&vtvalue)).into() } - unsafe extern "system" fn GetProperty, Impl: IWebBrowserApp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvtvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetProperty, Impl: IWebBrowserApp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvtvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetProperty(::core::mem::transmute(&property)) { @@ -22755,22 +22743,22 @@ impl IWebWizardExtension_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWebWizardHost_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn FinalBack(&self) -> ::windows_core::Result<()>; fn FinalNext(&self) -> ::windows_core::Result<()>; fn Cancel(&self) -> ::windows_core::Result<()>; fn SetCaption(&self, bstrcaption: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Caption(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn put_Property(&self, bstrpropertyname: &::windows_core::BSTR, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn get_Property(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; + fn put_Property(&self, bstrpropertyname: &::windows_core::BSTR, pvproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn get_Property(&self, bstrpropertyname: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; fn SetWizardButtons(&self, vfenableback: super::super::Foundation::VARIANT_BOOL, vfenablenext: super::super::Foundation::VARIANT_BOOL, vflastpage: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn SetHeaderText(&self, bstrheadertitle: &::windows_core::BSTR, bstrheadersubtitle: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWebWizardHost {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWebWizardHost_Vtbl { pub const fn new, Impl: IWebWizardHost_Impl, const OFFSET: isize>() -> IWebWizardHost_Vtbl { unsafe extern "system" fn FinalBack, Impl: IWebWizardHost_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -22804,12 +22792,12 @@ impl IWebWizardHost_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn put_Property, Impl: IWebWizardHost_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn put_Property, Impl: IWebWizardHost_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.put_Property(::core::mem::transmute(&bstrpropertyname), ::core::mem::transmute_copy(&pvproperty)).into() } - unsafe extern "system" fn get_Property, Impl: IWebWizardHost_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn get_Property, Impl: IWebWizardHost_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.get_Property(::core::mem::transmute(&bstrpropertyname)) { @@ -22847,14 +22835,14 @@ impl IWebWizardHost_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IWebWizardHost2_Impl: Sized + IWebWizardHost_Impl { fn SignString(&self, value: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IWebWizardHost2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IWebWizardHost2_Vtbl { pub const fn new, Impl: IWebWizardHost2_Impl, const OFFSET: isize>() -> IWebWizardHost2_Vtbl { unsafe extern "system" fn SignString, Impl: IWebWizardHost2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, value: ::std::mem::MaybeUninit<::windows_core::BSTR>, signedvalue: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/UI/Shell/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/Shell/mod.rs index 2e2e21a2de..40b08d5c48 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/Shell/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/Shell/mod.rs @@ -24,15 +24,15 @@ where let mut result__ = ::std::ptr::null_mut(); AssocCreateForClasses(::core::mem::transmute(rgclasses.as_ptr()), rgclasses.len().try_into().unwrap(), &T::IID, &mut result__).from_abi(result__) } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] #[inline] -pub unsafe fn AssocGetDetailsOfPropKey(psf: P0, pidl: *const Common::ITEMIDLIST, pkey: *const PropertiesSystem::PROPERTYKEY, pv: *mut super::super::System::Variant::VARIANT, pffoundpropkey: ::core::option::Option<*mut super::super::Foundation::BOOL>) -> ::windows_core::Result<()> +pub unsafe fn AssocGetDetailsOfPropKey(psf: P0, pidl: *const Common::ITEMIDLIST, pkey: *const PropertiesSystem::PROPERTYKEY, pv: *mut ::windows_core::VARIANT, pffoundpropkey: ::core::option::Option<*mut super::super::Foundation::BOOL>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("shell32.dll" "system" fn AssocGetDetailsOfPropKey(psf : * mut::core::ffi::c_void, pidl : *const Common:: ITEMIDLIST, pkey : *const PropertiesSystem:: PROPERTYKEY, pv : *mut super::super::System::Variant:: VARIANT, pffoundpropkey : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); - AssocGetDetailsOfPropKey(psf.into_param().abi(), pidl, pkey, pv, ::core::mem::transmute(pffoundpropkey.unwrap_or(::std::ptr::null_mut()))).ok() + ::windows_targets::link!("shell32.dll" "system" fn AssocGetDetailsOfPropKey(psf : * mut::core::ffi::c_void, pidl : *const Common:: ITEMIDLIST, pkey : *const PropertiesSystem:: PROPERTYKEY, pv : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >, pffoundpropkey : *mut super::super::Foundation:: BOOL) -> ::windows_core::HRESULT); + AssocGetDetailsOfPropKey(psf.into_param().abi(), pidl, pkey, ::core::mem::transmute(pv), ::core::mem::transmute(pffoundpropkey.unwrap_or(::std::ptr::null_mut()))).ok() } #[doc = "Required features: `\"Win32_UI_Shell_Common\"`"] #[cfg(feature = "Win32_UI_Shell_Common")] @@ -1250,18 +1250,18 @@ pub unsafe fn InitNetworkAddressControl() -> super::super::Foundation::BOOL { ::windows_targets::link!("shell32.dll" "system" fn InitNetworkAddressControl() -> super::super::Foundation:: BOOL); InitNetworkAddressControl() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`"] +#[cfg(feature = "Win32_UI_Shell_Common")] #[inline] -pub unsafe fn InitPropVariantFromStrRet(pstrret: *mut Common::STRRET, pidl: ::core::option::Option<*const Common::ITEMIDLIST>, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStrRet(pstrret : *mut Common:: STRRET, pidl : *const Common:: ITEMIDLIST, ppropvar : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - InitPropVariantFromStrRet(pstrret, ::core::mem::transmute(pidl.unwrap_or(::std::ptr::null())), ppropvar).ok() +pub unsafe fn InitPropVariantFromStrRet(pstrret: *mut Common::STRRET, pidl: ::core::option::Option<*const Common::ITEMIDLIST>, ppropvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn InitPropVariantFromStrRet(pstrret : *mut Common:: STRRET, pidl : *const Common:: ITEMIDLIST, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + InitPropVariantFromStrRet(pstrret, ::core::mem::transmute(pidl.unwrap_or(::std::ptr::null())), ::core::mem::transmute(ppropvar)).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`"] +#[cfg(feature = "Win32_UI_Shell_Common")] #[inline] -pub unsafe fn InitVariantFromStrRet(pstrret: *const Common::STRRET, pidl: *const Common::ITEMIDLIST) -> ::windows_core::Result { - ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromStrRet(pstrret : *const Common:: STRRET, pidl : *const Common:: ITEMIDLIST, pvar : *mut super::super::System::Variant:: VARIANT) -> ::windows_core::HRESULT); +pub unsafe fn InitVariantFromStrRet(pstrret: *const Common::STRRET, pidl: *const Common::ITEMIDLIST) -> ::windows_core::Result<::windows_core::VARIANT> { + ::windows_targets::link!("propsys.dll" "system" fn InitVariantFromStrRet(pstrret : *const Common:: STRRET, pidl : *const Common:: ITEMIDLIST, pvar : *mut ::std::mem::MaybeUninit <::windows_core::VARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); InitVariantFromStrRet(pstrret, pidl, &mut result__).from_abi(result__) } @@ -2451,12 +2451,12 @@ where ::windows_targets::link!("shell32.dll" "system" fn PickIconDlg(hwnd : super::super::Foundation:: HWND, psziconpath : ::windows_core::PWSTR, cchiconpath : u32, piiconindex : *mut i32) -> i32); PickIconDlg(hwnd.into_param().abi(), ::core::mem::transmute(psziconpath.as_ptr()), psziconpath.len().try_into().unwrap(), ::core::mem::transmute(piiconindex.unwrap_or(::std::ptr::null_mut()))) } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`"] +#[cfg(feature = "Win32_UI_Shell_Common")] #[inline] -pub unsafe fn PropVariantToStrRet(propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT, pstrret: *mut Common::STRRET) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStrRet(propvar : *const super::super::System::Com::StructuredStorage:: PROPVARIANT, pstrret : *mut Common:: STRRET) -> ::windows_core::HRESULT); - PropVariantToStrRet(propvar, pstrret).ok() +pub unsafe fn PropVariantToStrRet(propvar: *const ::windows_core::PROPVARIANT, pstrret: *mut Common::STRRET) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn PropVariantToStrRet(propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >, pstrret : *mut Common:: STRRET) -> ::windows_core::HRESULT); + PropVariantToStrRet(::core::mem::transmute(propvar), pstrret).ok() } #[inline] pub unsafe fn QISearch(that: *mut ::core::ffi::c_void, pqit: *const QITAB) -> ::windows_core::Result @@ -3716,14 +3716,14 @@ pub unsafe fn SHGetStockIconInfo(siid: SHSTOCKICONID, uflags: SHGSI_FLAGS, psii: ::windows_targets::link!("shell32.dll" "system" fn SHGetStockIconInfo(siid : SHSTOCKICONID, uflags : SHGSI_FLAGS, psii : *mut SHSTOCKICONINFO) -> ::windows_core::HRESULT); SHGetStockIconInfo(siid, uflags, psii).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] -pub unsafe fn SHGetTemporaryPropertyForItem(psi: P0, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result +pub unsafe fn SHGetTemporaryPropertyForItem(psi: P0, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("shell32.dll" "system" fn SHGetTemporaryPropertyForItem(psi : * mut::core::ffi::c_void, propkey : *const PropertiesSystem:: PROPERTYKEY, ppropvar : *mut super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); + ::windows_targets::link!("shell32.dll" "system" fn SHGetTemporaryPropertyForItem(psi : * mut::core::ffi::c_void, propkey : *const PropertiesSystem:: PROPERTYKEY, ppropvar : *mut ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); let mut result__ = ::std::mem::zeroed(); SHGetTemporaryPropertyForItem(psi.into_param().abi(), propkey, &mut result__).from_abi(result__) } @@ -4513,15 +4513,15 @@ where ::windows_targets::link!("shell32.dll" "system" fn SHSetLocalizedName(pszpath : ::windows_core::PCWSTR, pszresmodule : ::windows_core::PCWSTR, idsres : i32) -> ::windows_core::HRESULT); SHSetLocalizedName(pszpath.into_param().abi(), pszresmodule.into_param().abi(), idsres).ok() } -#[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] -#[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] +#[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] +#[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] #[inline] -pub unsafe fn SHSetTemporaryPropertyForItem(psi: P0, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> +pub unsafe fn SHSetTemporaryPropertyForItem(psi: P0, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - ::windows_targets::link!("shell32.dll" "system" fn SHSetTemporaryPropertyForItem(psi : * mut::core::ffi::c_void, propkey : *const PropertiesSystem:: PROPERTYKEY, propvar : *const super::super::System::Com::StructuredStorage:: PROPVARIANT) -> ::windows_core::HRESULT); - SHSetTemporaryPropertyForItem(psi.into_param().abi(), propkey, propvar).ok() + ::windows_targets::link!("shell32.dll" "system" fn SHSetTemporaryPropertyForItem(psi : * mut::core::ffi::c_void, propkey : *const PropertiesSystem:: PROPERTYKEY, propvar : *const ::std::mem::MaybeUninit <::windows_core::PROPVARIANT >) -> ::windows_core::HRESULT); + SHSetTemporaryPropertyForItem(psi.into_param().abi(), propkey, ::core::mem::transmute(propvar)).ok() } #[inline] pub unsafe fn SHSetThreadRef(punk: P0) -> ::windows_core::Result<()> @@ -5765,12 +5765,12 @@ pub unsafe fn UrlUnescapeW(pszurl: ::windows_core::PWSTR, pszunescaped: ::window ::windows_targets::link!("shlwapi.dll" "system" fn UrlUnescapeW(pszurl : ::windows_core::PWSTR, pszunescaped : ::windows_core::PWSTR, pcchunescaped : *mut u32, dwflags : u32) -> ::windows_core::HRESULT); UrlUnescapeW(::core::mem::transmute(pszurl), ::core::mem::transmute(pszunescaped), ::core::mem::transmute(pcchunescaped.unwrap_or(::std::ptr::null_mut())), dwflags).ok() } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common"))] +#[doc = "Required features: `\"Win32_UI_Shell_Common\"`"] +#[cfg(feature = "Win32_UI_Shell_Common")] #[inline] -pub unsafe fn VariantToStrRet(varin: *const super::super::System::Variant::VARIANT, pstrret: *mut Common::STRRET) -> ::windows_core::Result<()> { - ::windows_targets::link!("propsys.dll" "system" fn VariantToStrRet(varin : *const super::super::System::Variant:: VARIANT, pstrret : *mut Common:: STRRET) -> ::windows_core::HRESULT); - VariantToStrRet(varin, pstrret).ok() +pub unsafe fn VariantToStrRet(varin: *const ::windows_core::VARIANT, pstrret: *mut Common::STRRET) -> ::windows_core::Result<()> { + ::windows_targets::link!("propsys.dll" "system" fn VariantToStrRet(varin : *const ::std::mem::MaybeUninit <::windows_core::VARIANT >, pstrret : *mut Common:: STRRET) -> ::windows_core::HRESULT); + VariantToStrRet(::core::mem::transmute(varin), pstrret).ok() } #[inline] pub unsafe fn WhichPlatform() -> u32 { @@ -5883,8 +5883,8 @@ impl CIE4ConnectionPoint { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.EnumConnections)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] pub unsafe fn DoInvokeIE4(&self, pf: *mut super::super::Foundation::BOOL, ppv: *mut *mut ::core::ffi::c_void, dispid: i32, pdispparams: *mut super::super::System::Com::DISPPARAMS) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).DoInvokeIE4)(::windows_core::Interface::as_raw(self), pf, ppv, dispid, pdispparams).ok() } @@ -5902,9 +5902,9 @@ impl CIE4ConnectionPoint { #[doc(hidden)] pub struct CIE4ConnectionPoint_Vtbl { pub base__: super::super::System::Com::IConnectionPoint_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] + #[cfg(feature = "Win32_System_Com")] pub DoInvokeIE4: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pf: *mut super::super::Foundation::BOOL, ppv: *mut *mut ::core::ffi::c_void, dispid: i32, pdispparams: *mut super::super::System::Com::DISPPARAMS) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(not(feature = "Win32_System_Com"))] DoInvokeIE4: usize, #[cfg(feature = "Win32_UI_Shell_Common")] pub DoInvokePIDLIE4: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispid: i32, pidl: *mut Common::ITEMIDLIST, fcancancel: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, @@ -5926,9 +5926,7 @@ impl DFConstraint { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Name)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Value(&self) -> ::windows_core::Result { + pub unsafe fn Value(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Value)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -5939,10 +5937,7 @@ impl DFConstraint { pub struct DFConstraint_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Value: usize, + pub Value: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6077,29 +6072,33 @@ impl Folder { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ParseName)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NewFolder(&self, bname: P0, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NewFolder(&self, bname: P0, voptions: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), ::core::mem::transmute(voptions)).ok() + (::windows_core::Interface::vtable(self).NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).MoveHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn MoveHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).MoveHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).CopyHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn CopyHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).CopyHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDetailsOf(&self, vitem: super::super::System::Variant::VARIANT, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn GetDetailsOf(&self, vitem: P0, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetDetailsOf)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), icolumn, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetDetailsOf)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), icolumn, &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -6128,22 +6127,10 @@ pub struct Folder_Vtbl { pub ParseName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bname: ::std::mem::MaybeUninit<::windows_core::BSTR>, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ParseName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NewFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bname: ::std::mem::MaybeUninit<::windows_core::BSTR>, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NewFolder: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub MoveHere: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - MoveHere: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CopyHere: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CopyHere: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetDetailsOf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: super::super::System::Variant::VARIANT, icolumn: i32, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetDetailsOf: usize, + pub NewFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bname: ::std::mem::MaybeUninit<::windows_core::BSTR>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub MoveHere: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CopyHere: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voptions: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetDetailsOf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vitem: ::std::mem::MaybeUninit<::windows_core::VARIANT>, icolumn: i32, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6193,29 +6180,33 @@ impl Folder2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.ParseName)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NewFolder(&self, bname: P0, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NewFolder(&self, bname: P0, voptions: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), ::core::mem::transmute(voptions)).ok() + (::windows_core::Interface::vtable(self).base__.NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.MoveHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn MoveHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.MoveHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.CopyHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn CopyHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.CopyHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDetailsOf(&self, vitem: super::super::System::Variant::VARIANT, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn GetDetailsOf(&self, vitem: P0, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetDetailsOf)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), icolumn, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetDetailsOf)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), icolumn, &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6300,29 +6291,33 @@ impl Folder3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.ParseName)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NewFolder(&self, bname: P0, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NewFolder(&self, bname: P0, voptions: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), ::core::mem::transmute(voptions)).ok() + (::windows_core::Interface::vtable(self).base__.base__.NewFolder)(::windows_core::Interface::as_raw(self), bname.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn MoveHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.MoveHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn MoveHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.MoveHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CopyHere(&self, vitem: super::super::System::Variant::VARIANT, voptions: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.CopyHere)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), ::core::mem::transmute(voptions)).ok() + pub unsafe fn CopyHere(&self, vitem: P0, voptions: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.CopyHere)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), voptions.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetDetailsOf(&self, vitem: super::super::System::Variant::VARIANT, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> { + pub unsafe fn GetDetailsOf(&self, vitem: P0, icolumn: i32) -> ::windows_core::Result<::windows_core::BSTR> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.GetDetailsOf)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vitem), icolumn, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.GetDetailsOf)(::windows_core::Interface::as_raw(self), vitem.into_param().abi(), icolumn, &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -6449,10 +6444,11 @@ impl FolderItem { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Verbs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeVerb(&self, vverb: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InvokeVerb)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vverb)).ok() + pub unsafe fn InvokeVerb(&self, vverb: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).InvokeVerb)(::windows_core::Interface::as_raw(self), vverb.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6491,10 +6487,7 @@ pub struct FolderItem_Vtbl { pub Verbs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppfic: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Verbs: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeVerb: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeVerb: usize, + pub InvokeVerb: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6582,19 +6575,20 @@ impl FolderItem2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Verbs)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeVerb(&self, vverb: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.InvokeVerb)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vverb)).ok() + pub unsafe fn InvokeVerb(&self, vverb: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.InvokeVerb)(::windows_core::Interface::as_raw(self), vverb.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeVerbEx(&self, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InvokeVerbEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vverb), ::core::mem::transmute(vargs)).ok() + pub unsafe fn InvokeVerbEx(&self, vverb: P0, vargs: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).InvokeVerbEx)(::windows_core::Interface::as_raw(self), vverb.into_param().abi(), vargs.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExtendedProperty(&self, bstrpropname: P0) -> ::windows_core::Result + pub unsafe fn ExtendedProperty(&self, bstrpropname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -6607,14 +6601,8 @@ impl FolderItem2 { #[doc(hidden)] pub struct FolderItem2_Vtbl { pub base__: FolderItem_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeVerbEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeVerbEx: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExtendedProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvret: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExtendedProperty: usize, + pub InvokeVerbEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ExtendedProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvret: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6690,11 +6678,14 @@ impl FolderItemVerbs { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -6715,9 +6706,9 @@ pub struct FolderItemVerbs_Vtbl { pub Parent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Parent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -6748,11 +6739,14 @@ impl FolderItems { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -6773,9 +6767,9 @@ pub struct FolderItems_Vtbl { pub Parent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Parent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -6806,20 +6800,25 @@ impl FolderItems2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeVerbEx(&self, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InvokeVerbEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vverb), ::core::mem::transmute(vargs)).ok() + pub unsafe fn InvokeVerbEx(&self, vverb: P0, vargs: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).InvokeVerbEx)(::windows_core::Interface::as_raw(self), vverb.into_param().abi(), vargs.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -6827,10 +6826,7 @@ impl FolderItems2 { #[doc(hidden)] pub struct FolderItems2_Vtbl { pub base__: FolderItems_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InvokeVerbEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InvokeVerbEx: usize, + pub InvokeVerbEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vverb: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -6859,20 +6855,25 @@ impl FolderItems3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InvokeVerbEx(&self, vverb: super::super::System::Variant::VARIANT, vargs: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.InvokeVerbEx)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vverb), ::core::mem::transmute(vargs)).ok() + pub unsafe fn InvokeVerbEx(&self, vverb: P0, vargs: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.InvokeVerbEx)(::windows_core::Interface::as_raw(self), vverb.into_param().abi(), vargs.into_param().abi()).ok() } pub unsafe fn Filter(&self, grfflags: i32, bstrfilespec: P0) -> ::windows_core::Result<()> where @@ -7999,21 +8000,19 @@ impl IBrowserService { { (::windows_core::Interface::vtable(self).CacheOLEServer)(::windows_core::Interface::as_raw(self), pole.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSetCodePage(&self, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetSetCodePage(&self, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).GetSetCodePage)(::windows_core::Interface::as_raw(self), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).GetSetCodePage)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), pvarargin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), ::core::mem::transmute(pvarargin), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_Graphics_Gdi\"`"] #[cfg(feature = "Win32_Graphics_Gdi")] @@ -8097,13 +8096,10 @@ pub struct IBrowserService_Vtbl { pub CacheOLEServer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pole: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] CacheOLEServer: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSetCodePage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarin: *const super::super::System::Variant::VARIANT, pvarout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSetCodePage: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnHttpEquiv: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psv: *mut ::core::ffi::c_void, fdone: super::super::Foundation::BOOL, pvarargin: *const super::super::System::Variant::VARIANT, pvarargout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub GetSetCodePage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Ole")] + pub OnHttpEquiv: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psv: *mut ::core::ffi::c_void, fdone: super::super::Foundation::BOOL, pvarargin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarargout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Ole"))] OnHttpEquiv: usize, #[cfg(feature = "Win32_Graphics_Gdi")] pub GetPalette: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hpal: *mut super::super::Graphics::Gdi::HPALETTE) -> ::windows_core::HRESULT, @@ -8254,21 +8250,19 @@ impl IBrowserService2 { { (::windows_core::Interface::vtable(self).base__.CacheOLEServer)(::windows_core::Interface::as_raw(self), pole.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSetCodePage(&self, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetSetCodePage(&self, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), pvarargin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), ::core::mem::transmute(pvarargin), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_Graphics_Gdi\"`"] #[cfg(feature = "Win32_Graphics_Gdi")] @@ -8437,9 +8431,7 @@ impl IBrowserService2 { pub unsafe fn _SwitchActivationNow(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self)._SwitchActivationNow)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const super::super::System::Variant::VARIANT>, pvarargout: ::core::option::Option<*mut super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const ::windows_core::VARIANT>, pvarargout: ::core::option::Option<*mut ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam, @@ -8651,10 +8643,7 @@ pub struct IBrowserService2_Vtbl { #[cfg(not(all(feature = "Win32_System_Ole", feature = "Win32_UI_Shell_Common")))] _TryShell2Rename: usize, pub _SwitchActivationNow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub _ExecChildren: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkbar: *mut ::core::ffi::c_void, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const super::super::System::Variant::VARIANT, pvarargout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - _ExecChildren: usize, + pub _ExecChildren: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkbar: *mut ::core::ffi::c_void, fbroadcast: super::super::Foundation::BOOL, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvarargin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarargout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub _SendChildren: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwndbar: super::super::Foundation::HWND, fbroadcast: super::super::Foundation::BOOL, umsg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows_core::HRESULT, pub GetFolderSetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfsd: *mut FOLDERSETDATA) -> ::windows_core::HRESULT, pub _OnFocusChange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, itb: u32) -> ::windows_core::HRESULT, @@ -8856,21 +8845,19 @@ impl IBrowserService3 { { (::windows_core::Interface::vtable(self).base__.base__.CacheOLEServer)(::windows_core::Interface::as_raw(self), pole.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSetCodePage(&self, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetSetCodePage(&self, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), pvarargin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), ::core::mem::transmute(pvarargin), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_Graphics_Gdi\"`"] #[cfg(feature = "Win32_Graphics_Gdi")] @@ -9039,9 +9026,7 @@ impl IBrowserService3 { pub unsafe fn _SwitchActivationNow(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__._SwitchActivationNow)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const super::super::System::Variant::VARIANT>, pvarargout: ::core::option::Option<*mut super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const ::windows_core::VARIANT>, pvarargout: ::core::option::Option<*mut ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam, @@ -9362,21 +9347,19 @@ impl IBrowserService4 { { (::windows_core::Interface::vtable(self).base__.base__.base__.CacheOLEServer)(::windows_core::Interface::as_raw(self), pole.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSetCodePage(&self, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result { + pub unsafe fn GetSetCodePage(&self, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.GetSetCodePage)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn OnHttpEquiv(&self, psv: P0, fdone: P1, pvarargin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, P1: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), pvarargin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.OnHttpEquiv)(::windows_core::Interface::as_raw(self), psv.into_param().abi(), fdone.into_param().abi(), ::core::mem::transmute(pvarargin), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_Graphics_Gdi\"`"] #[cfg(feature = "Win32_Graphics_Gdi")] @@ -9545,9 +9528,7 @@ impl IBrowserService4 { pub unsafe fn _SwitchActivationNow(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__._SwitchActivationNow)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const super::super::System::Variant::VARIANT>, pvarargout: ::core::option::Option<*mut super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn _ExecChildren(&self, punkbar: P0, fbroadcast: P1, pguidcmdgroup: ::core::option::Option<*const ::windows_core::GUID>, ncmdid: u32, ncmdexecopt: u32, pvarargin: ::core::option::Option<*const ::windows_core::VARIANT>, pvarargout: ::core::option::Option<*mut ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam, @@ -9924,9 +9905,9 @@ impl IColumnProvider { pub unsafe fn GetColumnInfo(&self, dwindex: u32, psci: *mut SHCOLUMNINFO) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetColumnInfo)(::windows_core::Interface::as_raw(self), dwindex, psci).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetItemData(&self, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetItemData(&self, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetItemData)(::windows_core::Interface::as_raw(self), pscid, pscd, &mut result__).from_abi(result__) } @@ -9940,9 +9921,9 @@ pub struct IColumnProvider_Vtbl { pub GetColumnInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwindex: u32, psci: *mut SHCOLUMNINFO) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] GetColumnInfo: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetItemData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA, pvardata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetItemData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pscid: *const PropertiesSystem::PROPERTYKEY, pscd: *const SHCOLUMNDATA, pvardata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetItemData: usize, } ::windows_core::imp::com_interface!(ICommDlgBrowser, ICommDlgBrowser_Vtbl, 0x000214f1_0000_0000_c000_000000000046); @@ -10975,9 +10956,9 @@ impl ICredentialProviderUser { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetStringValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetValue(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetValue(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } @@ -10992,9 +10973,9 @@ pub struct ICredentialProviderUser_Vtbl { pub GetStringValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, stringvalue: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetStringValue: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, value: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, value: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetValue: usize, } ::windows_core::imp::com_interface!(ICredentialProviderUserArray, ICredentialProviderUserArray_Vtbl, 0x90c119ae_0f18_4520_a1f1_114366a40fe8); @@ -11770,20 +11751,15 @@ pub struct IDisplayItem_Vtbl { ::windows_core::imp::com_interface!(IDocViewSite, IDocViewSite_Vtbl, 0x87d605e0_c511_11cf_89a9_00a0c9054129); ::windows_core::imp::interface_hierarchy!(IDocViewSite, ::windows_core::IUnknown); impl IDocViewSite { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnSetTitle(&self, pvtitle: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnSetTitle)(::windows_core::Interface::as_raw(self), pvtitle).ok() + pub unsafe fn OnSetTitle(&self, pvtitle: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnSetTitle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvtitle)).ok() } } #[repr(C)] #[doc(hidden)] pub struct IDocViewSite_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnSetTitle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtitle: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnSetTitle: usize, + pub OnSetTitle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtitle: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Ole")] ::windows_core::imp::com_interface!( @@ -12610,10 +12586,10 @@ impl IExpDispSupport { pub unsafe fn OnTranslateAccelerator(&self, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).OnTranslateAccelerator)(::windows_core::Interface::as_raw(self), pmsg, grfmodifiers).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnInvoke)(::windows_core::Interface::as_raw(self), dispidmember, iid, lcid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnInvoke)(::windows_core::Interface::as_raw(self), dispidmember, iid, lcid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } } #[repr(C)] @@ -12628,9 +12604,9 @@ pub struct IExpDispSupport_Vtbl { pub OnTranslateAccelerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_WindowsAndMessaging"))] OnTranslateAccelerator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OnInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OnInvoke: usize, } ::windows_core::imp::com_interface!(IExpDispSupportXP, IExpDispSupportXP_Vtbl, 0x2f0dd58c_f789_4f14_99fb_9293b3c9c212); @@ -12647,10 +12623,10 @@ impl IExpDispSupportXP { pub unsafe fn OnTranslateAccelerator(&self, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).OnTranslateAccelerator)(::windows_core::Interface::as_raw(self), pmsg, grfmodifiers).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnInvoke)(::windows_core::Interface::as_raw(self), dispidmember, iid, lcid, wflags, pdispparams, pvarresult, pexcepinfo, puargerr).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn OnInvoke(&self, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::windows_core::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnInvoke)(::windows_core::Interface::as_raw(self), dispidmember, iid, lcid, wflags, pdispparams, ::core::mem::transmute(pvarresult), pexcepinfo, puargerr).ok() } } #[repr(C)] @@ -12665,9 +12641,9 @@ pub struct IExpDispSupportXP_Vtbl { pub OnTranslateAccelerator: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pmsg: *const super::WindowsAndMessaging::MSG, grfmodifiers: u32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_WindowsAndMessaging"))] OnTranslateAccelerator: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Variant::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub OnInvoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dispidmember: i32, iid: *const ::windows_core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] OnInvoke: usize, } ::windows_core::imp::com_interface!(IExplorerBrowser, IExplorerBrowser_Vtbl, 0xdfd3b6b5_c10c_4be9_85f6_a66969f402f6); @@ -14393,27 +14369,21 @@ impl IFileSearchBand { pub unsafe fn SetFocus(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).SetFocus)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSearchParameters(&self, pbstrsearchid: *const ::windows_core::BSTR, bnavtoresults: P0, pvarscope: *const super::super::System::Variant::VARIANT, pvarqueryfile: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetSearchParameters(&self, pbstrsearchid: *const ::windows_core::BSTR, bnavtoresults: P0, pvarscope: *const ::windows_core::VARIANT, pvarqueryfile: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).SetSearchParameters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pbstrsearchid), bnavtoresults.into_param().abi(), pvarscope, pvarqueryfile).ok() + (::windows_core::Interface::vtable(self).SetSearchParameters)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pbstrsearchid), bnavtoresults.into_param().abi(), ::core::mem::transmute(pvarscope), ::core::mem::transmute(pvarqueryfile)).ok() } pub unsafe fn SearchID(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SearchID)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Scope(&self) -> ::windows_core::Result { + pub unsafe fn Scope(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Scope)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn QueryFile(&self) -> ::windows_core::Result { + pub unsafe fn QueryFile(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QueryFile)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -14424,19 +14394,10 @@ impl IFileSearchBand { pub struct IFileSearchBand_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub SetFocus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSearchParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsearchid: *const ::std::mem::MaybeUninit<::windows_core::BSTR>, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const super::super::System::Variant::VARIANT, pvarqueryfile: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSearchParameters: usize, + pub SetSearchParameters: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsearchid: *const ::std::mem::MaybeUninit<::windows_core::BSTR>, bnavtoresults: super::super::Foundation::VARIANT_BOOL, pvarscope: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarqueryfile: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SearchID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrsearchid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Scope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarscope: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Scope: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub QueryFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarfile: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - QueryFile: usize, + pub Scope: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarscope: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub QueryFile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarfile: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IFileSyncMergeHandler, IFileSyncMergeHandler_Vtbl, 0xd97b5aac_c792_433c_975d_35c4eadc7a9d); ::windows_core::imp::interface_hierarchy!(IFileSyncMergeHandler, ::windows_core::IUnknown); @@ -14793,14 +14754,14 @@ impl IFolderView2 { pub unsafe fn GetGroupBy(&self, pkey: *mut PropertiesSystem::PROPERTYKEY, pfascending: ::core::option::Option<*mut super::super::Foundation::BOOL>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GetGroupBy)(::windows_core::Interface::as_raw(self), pkey, ::core::mem::transmute(pfascending.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn SetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetViewProperty)(::windows_core::Interface::as_raw(self), pidl, propkey, propvar).ok() + #[doc = "Required features: `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn SetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetViewProperty)(::windows_core::Interface::as_raw(self), pidl, propkey, ::core::mem::transmute(propvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn GetViewProperty(&self, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetViewProperty)(::windows_core::Interface::as_raw(self), pidl, propkey, &mut result__).from_abi(result__) } @@ -14922,13 +14883,13 @@ pub struct IFolderView2_Vtbl { pub GetGroupBy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pkey: *mut PropertiesSystem::PROPERTYKEY, pfascending: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetGroupBy: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub SetViewProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub SetViewProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, propvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] SetViewProperty: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetViewProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub GetViewProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] GetViewProperty: usize, #[cfg(feature = "Win32_UI_Shell_Common")] pub SetTileViewProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, pszproplist: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, @@ -16447,9 +16408,7 @@ impl INameSpaceTreeAccessible { { (::windows_core::Interface::vtable(self).OnDoDefaultAccessibilityAction)(::windows_core::Interface::as_raw(self), psi.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnGetAccessibilityRole(&self, psi: P0) -> ::windows_core::Result + pub unsafe fn OnGetAccessibilityRole(&self, psi: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -16463,10 +16422,7 @@ pub struct INameSpaceTreeAccessible_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub OnGetDefaultAccessibilityAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pbstrdefaultaction: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub OnDoDefaultAccessibilityAction: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnGetAccessibilityRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pvarrole: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnGetAccessibilityRole: usize, + pub OnGetAccessibilityRole: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, psi: *mut ::core::ffi::c_void, pvarrole: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(INameSpaceTreeControl, INameSpaceTreeControl_Vtbl, 0x028212a3_b627_47e9_8856_c14265554e4f); ::windows_core::imp::interface_hierarchy!(INameSpaceTreeControl, ::windows_core::IUnknown); @@ -17006,23 +16962,19 @@ pub struct INameSpaceTreeControlFolderCapabilities_Vtbl { ::windows_core::imp::com_interface!(INamedPropertyBag, INamedPropertyBag_Vtbl, 0xfb700430_952c_11d1_946f_000000000000); ::windows_core::imp::interface_hierarchy!(INamedPropertyBag, ::windows_core::IUnknown); impl INamedPropertyBag { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn ReadPropertyNPB(&self, pszbagname: P0, pszpropname: P1, pvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn ReadPropertyNPB(&self, pszbagname: P0, pszpropname: P1, pvar: *mut ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).ReadPropertyNPB)(::windows_core::Interface::as_raw(self), pszbagname.into_param().abi(), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).ReadPropertyNPB)(::windows_core::Interface::as_raw(self), pszbagname.into_param().abi(), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub unsafe fn WritePropertyNPB(&self, pszbagname: P0, pszpropname: P1, pvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::Result<()> + pub unsafe fn WritePropertyNPB(&self, pszbagname: P0, pszpropname: P1, pvar: *const ::windows_core::PROPVARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::PCWSTR>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, { - (::windows_core::Interface::vtable(self).WritePropertyNPB)(::windows_core::Interface::as_raw(self), pszbagname.into_param().abi(), pszpropname.into_param().abi(), pvar).ok() + (::windows_core::Interface::vtable(self).WritePropertyNPB)(::windows_core::Interface::as_raw(self), pszbagname.into_param().abi(), pszpropname.into_param().abi(), ::core::mem::transmute(pvar)).ok() } pub unsafe fn RemovePropertyNPB(&self, pszbagname: P0, pszpropname: P1) -> ::windows_core::Result<()> where @@ -17036,14 +16988,8 @@ impl INamedPropertyBag { #[doc(hidden)] pub struct INamedPropertyBag_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub ReadPropertyNPB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - ReadPropertyNPB: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant"))] - pub WritePropertyNPB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *const super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant")))] - WritePropertyNPB: usize, + pub ReadPropertyNPB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + pub WritePropertyNPB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR, pvar: *const ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, pub RemovePropertyNPB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pszbagname: ::windows_core::PCWSTR, pszpropname: ::windows_core::PCWSTR) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(INamespaceWalk, INamespaceWalk_Vtbl, 0x57ced8a7_3f4a_432c_9350_30f24483f74f); @@ -17327,17 +17273,13 @@ impl INewWDEvents { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Caption)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), pvproperty).ok() + (::windows_core::Interface::vtable(self).base__.put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(pvproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -19420,20 +19362,24 @@ impl IShellDispatch { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -19441,15 +19387,17 @@ impl IShellDispatch { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -19516,26 +19464,20 @@ pub struct IShellDispatch_Vtbl { pub Parent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Parent: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NameSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub NameSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] NameSpace: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BrowseForFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, options: i32, rootfolder: super::super::System::Variant::VARIANT, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub BrowseForFolder: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hwnd: i32, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, options: i32, rootfolder: ::std::mem::MaybeUninit<::windows_core::VARIANT>, ppsdf: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] BrowseForFolder: usize, #[cfg(feature = "Win32_System_Com")] pub Windows: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Windows: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Open: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Explore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Explore: usize, + pub Open: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Explore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub MinimizeAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub UndoMinimizeALL: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub FileRun: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -19576,20 +19518,24 @@ impl IShellDispatch2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -19597,15 +19543,17 @@ impl IShellDispatch2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -19666,13 +19614,15 @@ impl IShellDispatch2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsRestricted)(::windows_core::Interface::as_raw(self), group.into_param().abi(), restriction.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShellExecute(&self, file: P0, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ShellExecute(&self, file: P0, vargs: P1, vdir: P2, voperation: P3, vshow: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), ::core::mem::transmute(vargs), ::core::mem::transmute(vdir), ::core::mem::transmute(voperation), ::core::mem::transmute(vshow)).ok() + (::windows_core::Interface::vtable(self).ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), vargs.into_param().abi(), vdir.into_param().abi(), voperation.into_param().abi(), vshow.into_param().abi()).ok() } pub unsafe fn FindPrinter(&self, name: P0, location: P1, model: P2) -> ::windows_core::Result<()> where @@ -19682,59 +19632,50 @@ impl IShellDispatch2 { { (::windows_core::Interface::vtable(self).FindPrinter)(::windows_core::Interface::as_raw(self), name.into_param().abi(), location.into_param().abi(), model.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetSystemInformation)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStart(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStart(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStop(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStop(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsServiceRunning)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).CanStartStopService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), ::core::mem::transmute(bshow), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), bshow.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -19743,35 +19684,14 @@ impl IShellDispatch2 { pub struct IShellDispatch2_Vtbl { pub base__: IShellDispatch_Vtbl, pub IsRestricted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, group: ::std::mem::MaybeUninit<::windows_core::BSTR>, restriction: ::std::mem::MaybeUninit<::windows_core::BSTR>, plrestrictvalue: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ShellExecute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, file: ::std::mem::MaybeUninit<::windows_core::BSTR>, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ShellExecute: usize, + pub ShellExecute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, file: ::std::mem::MaybeUninit<::windows_core::BSTR>, vargs: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vdir: ::std::mem::MaybeUninit<::windows_core::VARIANT>, voperation: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vshow: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub FindPrinter: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, location: ::std::mem::MaybeUninit<::windows_core::BSTR>, model: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetSystemInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetSystemInformation: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ServiceStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ServiceStart: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ServiceStop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ServiceStop: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub IsServiceRunning: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, prunning: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - IsServiceRunning: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CanStartStopService: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcanstartstop: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CanStartStopService: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ShowBrowserBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bshow: super::super::System::Variant::VARIANT, psuccess: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ShowBrowserBar: usize, + pub GetSystemInformation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ServiceStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ServiceStop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, persistent: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub IsServiceRunning: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, prunning: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub CanStartStopService: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, servicename: ::std::mem::MaybeUninit<::windows_core::BSTR>, pcanstartstop: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ShowBrowserBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrclsid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bshow: ::std::mem::MaybeUninit<::windows_core::VARIANT>, psuccess: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -19796,20 +19716,24 @@ impl IShellDispatch3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -19817,15 +19741,17 @@ impl IShellDispatch3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -19886,13 +19812,15 @@ impl IShellDispatch3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.IsRestricted)(::windows_core::Interface::as_raw(self), group.into_param().abi(), restriction.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShellExecute(&self, file: P0, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ShellExecute(&self, file: P0, vargs: P1, vdir: P2, voperation: P3, vshow: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), ::core::mem::transmute(vargs), ::core::mem::transmute(vdir), ::core::mem::transmute(voperation), ::core::mem::transmute(vshow)).ok() + (::windows_core::Interface::vtable(self).base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), vargs.into_param().abi(), vdir.into_param().abi(), voperation.into_param().abi(), vshow.into_param().abi()).ok() } pub unsafe fn FindPrinter(&self, name: P0, location: P1, model: P2) -> ::windows_core::Result<()> where @@ -19902,67 +19830,57 @@ impl IShellDispatch3 { { (::windows_core::Interface::vtable(self).base__.FindPrinter)(::windows_core::Interface::as_raw(self), name.into_param().abi(), location.into_param().abi(), model.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetSystemInformation)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStart(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStart(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStop(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStop(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.IsServiceRunning)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.CanStartStopService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), ::core::mem::transmute(bshow), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), bshow.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToRecent(&self, varfile: super::super::System::Variant::VARIANT, bstrcategory: P0) -> ::windows_core::Result<()> + pub unsafe fn AddToRecent(&self, varfile: P0, bstrcategory: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddToRecent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varfile), bstrcategory.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).AddToRecent)(::windows_core::Interface::as_raw(self), varfile.into_param().abi(), bstrcategory.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -19970,10 +19888,7 @@ impl IShellDispatch3 { #[doc(hidden)] pub struct IShellDispatch3_Vtbl { pub base__: IShellDispatch2_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddToRecent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varfile: super::super::System::Variant::VARIANT, bstrcategory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddToRecent: usize, + pub AddToRecent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varfile: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstrcategory: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -19998,20 +19913,24 @@ impl IShellDispatch4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -20019,15 +19938,17 @@ impl IShellDispatch4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -20088,13 +20009,15 @@ impl IShellDispatch4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.IsRestricted)(::windows_core::Interface::as_raw(self), group.into_param().abi(), restriction.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShellExecute(&self, file: P0, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ShellExecute(&self, file: P0, vargs: P1, vdir: P2, voperation: P3, vshow: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), ::core::mem::transmute(vargs), ::core::mem::transmute(vdir), ::core::mem::transmute(voperation), ::core::mem::transmute(vshow)).ok() + (::windows_core::Interface::vtable(self).base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), vargs.into_param().abi(), vdir.into_param().abi(), voperation.into_param().abi(), vshow.into_param().abi()).ok() } pub unsafe fn FindPrinter(&self, name: P0, location: P1, model: P2) -> ::windows_core::Result<()> where @@ -20104,67 +20027,57 @@ impl IShellDispatch4 { { (::windows_core::Interface::vtable(self).base__.base__.FindPrinter)(::windows_core::Interface::as_raw(self), name.into_param().abi(), location.into_param().abi(), model.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.GetSystemInformation)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStart(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStart(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStop(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStop(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.IsServiceRunning)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.CanStartStopService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), ::core::mem::transmute(bshow), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), bshow.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToRecent(&self, varfile: super::super::System::Variant::VARIANT, bstrcategory: P0) -> ::windows_core::Result<()> + pub unsafe fn AddToRecent(&self, varfile: P0, bstrcategory: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.AddToRecent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varfile), bstrcategory.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.AddToRecent)(::windows_core::Interface::as_raw(self), varfile.into_param().abi(), bstrcategory.into_param().abi()).ok() } pub unsafe fn WindowsSecurity(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).WindowsSecurity)(::windows_core::Interface::as_raw(self)).ok() @@ -20172,9 +20085,7 @@ impl IShellDispatch4 { pub unsafe fn ToggleDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ToggleDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result + pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -20193,10 +20104,7 @@ pub struct IShellDispatch4_Vtbl { pub base__: IShellDispatch3_Vtbl, pub WindowsSecurity: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ToggleDesktop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExplorerPolicy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpolicyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ExplorerPolicy: usize, + pub ExplorerPolicy: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpolicyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetSetting: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lsetting: i32, presult: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -20222,20 +20130,24 @@ impl IShellDispatch5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -20243,15 +20155,17 @@ impl IShellDispatch5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -20312,13 +20226,15 @@ impl IShellDispatch5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsRestricted)(::windows_core::Interface::as_raw(self), group.into_param().abi(), restriction.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShellExecute(&self, file: P0, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ShellExecute(&self, file: P0, vargs: P1, vdir: P2, voperation: P3, vshow: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), ::core::mem::transmute(vargs), ::core::mem::transmute(vdir), ::core::mem::transmute(voperation), ::core::mem::transmute(vshow)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), vargs.into_param().abi(), vdir.into_param().abi(), voperation.into_param().abi(), vshow.into_param().abi()).ok() } pub unsafe fn FindPrinter(&self, name: P0, location: P1, model: P2) -> ::windows_core::Result<()> where @@ -20328,67 +20244,57 @@ impl IShellDispatch5 { { (::windows_core::Interface::vtable(self).base__.base__.base__.FindPrinter)(::windows_core::Interface::as_raw(self), name.into_param().abi(), location.into_param().abi(), model.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.GetSystemInformation)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStart(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStart(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStop(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStop(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsServiceRunning)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.CanStartStopService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), ::core::mem::transmute(bshow), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), bshow.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToRecent(&self, varfile: super::super::System::Variant::VARIANT, bstrcategory: P0) -> ::windows_core::Result<()> + pub unsafe fn AddToRecent(&self, varfile: P0, bstrcategory: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.AddToRecent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varfile), bstrcategory.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddToRecent)(::windows_core::Interface::as_raw(self), varfile.into_param().abi(), bstrcategory.into_param().abi()).ok() } pub unsafe fn WindowsSecurity(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.WindowsSecurity)(::windows_core::Interface::as_raw(self)).ok() @@ -20396,9 +20302,7 @@ impl IShellDispatch5 { pub unsafe fn ToggleDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ToggleDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result + pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -20443,20 +20347,24 @@ impl IShellDispatch6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Parent)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NameSpace(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn NameSpace(&self, vdir: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.NameSpace)(::windows_core::Interface::as_raw(self), vdir.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn BrowseForFolder(&self, hwnd: i32, title: P0, options: i32, rootfolder: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, ::core::mem::transmute(rootfolder), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.BrowseForFolder)(::windows_core::Interface::as_raw(self), hwnd, title.into_param().abi(), options, rootfolder.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -20464,15 +20372,17 @@ impl IShellDispatch6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Windows)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Open(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Open(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Open)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Explore(&self, vdir: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vdir)).ok() + pub unsafe fn Explore(&self, vdir: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.Explore)(::windows_core::Interface::as_raw(self), vdir.into_param().abi()).ok() } pub unsafe fn MinimizeAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.MinimizeAll)(::windows_core::Interface::as_raw(self)).ok() @@ -20533,13 +20443,15 @@ impl IShellDispatch6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsRestricted)(::windows_core::Interface::as_raw(self), group.into_param().abi(), restriction.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShellExecute(&self, file: P0, vargs: super::super::System::Variant::VARIANT, vdir: super::super::System::Variant::VARIANT, voperation: super::super::System::Variant::VARIANT, vshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn ShellExecute(&self, file: P0, vargs: P1, vdir: P2, voperation: P3, vshow: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), ::core::mem::transmute(vargs), ::core::mem::transmute(vdir), ::core::mem::transmute(voperation), ::core::mem::transmute(vshow)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShellExecute)(::windows_core::Interface::as_raw(self), file.into_param().abi(), vargs.into_param().abi(), vdir.into_param().abi(), voperation.into_param().abi(), vshow.into_param().abi()).ok() } pub unsafe fn FindPrinter(&self, name: P0, location: P1, model: P2) -> ::windows_core::Result<()> where @@ -20549,67 +20461,57 @@ impl IShellDispatch6 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.FindPrinter)(::windows_core::Interface::as_raw(self), name.into_param().abi(), location.into_param().abi(), model.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result + pub unsafe fn GetSystemInformation(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.GetSystemInformation)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStart(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStart(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ServiceStart)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ServiceStop(&self, servicename: P0, persistent: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ServiceStop(&self, servicename: P0, persistent: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), ::core::mem::transmute(persistent), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ServiceStop)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), persistent.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn IsServiceRunning(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsServiceRunning)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result + pub unsafe fn CanStartStopService(&self, servicename: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.CanStartStopService)(::windows_core::Interface::as_raw(self), servicename.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserBar(&self, bstrclsid: P0, bshow: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), ::core::mem::transmute(bshow), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShowBrowserBar)(::windows_core::Interface::as_raw(self), bstrclsid.into_param().abi(), bshow.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToRecent(&self, varfile: super::super::System::Variant::VARIANT, bstrcategory: P0) -> ::windows_core::Result<()> + pub unsafe fn AddToRecent(&self, varfile: P0, bstrcategory: P1) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.AddToRecent)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varfile), bstrcategory.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.AddToRecent)(::windows_core::Interface::as_raw(self), varfile.into_param().abi(), bstrcategory.into_param().abi()).ok() } pub unsafe fn WindowsSecurity(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.WindowsSecurity)(::windows_core::Interface::as_raw(self)).ok() @@ -20617,9 +20519,7 @@ impl IShellDispatch6 { pub unsafe fn ToggleDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.ToggleDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result + pub unsafe fn ExplorerPolicy(&self, bstrpolicyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -20968,9 +20868,9 @@ impl IShellFolder2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDefaultColumnState)(::windows_core::Interface::as_raw(self), icolumn, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetDetailsEx(&self, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_Common\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub unsafe fn GetDetailsEx(&self, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDetailsEx)(::windows_core::Interface::as_raw(self), pidl, pscid, &mut result__).from_abi(result__) } @@ -20993,9 +20893,9 @@ pub struct IShellFolder2_Vtbl { pub EnumSearches: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetDefaultColumn: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwres: u32, psort: *mut u32, pdisplay: *mut u32) -> ::windows_core::HRESULT, pub GetDefaultColumnState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, icolumn: u32, pcsflags: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetDetailsEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY, pv: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem"))] + pub GetDetailsEx: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, pscid: *const PropertiesSystem::PROPERTYKEY, pv: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(all(feature = "Win32_UI_Shell_Common", feature = "Win32_UI_Shell_PropertiesSystem")))] GetDetailsEx: usize, #[cfg(feature = "Win32_UI_Shell_Common")] pub GetDetailsOf: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidl: *const Common::ITEMIDLIST, icolumn: u32, psd: *mut Common::SHELLDETAILS) -> ::windows_core::HRESULT, @@ -21322,19 +21222,19 @@ impl IShellFolderViewDual { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FocusedItem)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelectItem(&self, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SelectItem)(::windows_core::Interface::as_raw(self), pvfi, dwflags).ok() + pub unsafe fn SelectItem(&self, pvfi: *const ::windows_core::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SelectItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvfi), dwflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: super::super::System::Variant::VARIANT, vy: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: P1, vy: P2) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), ::core::mem::transmute(vx), ::core::mem::transmute(vy), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), vx.into_param().abi(), vy.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -21372,13 +21272,10 @@ pub struct IShellFolderViewDual_Vtbl { pub FocusedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] FocusedItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelectItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelectItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PopupItemMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfi: *mut ::core::ffi::c_void, vx: super::super::System::Variant::VARIANT, vy: super::super::System::Variant::VARIANT, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub SelectItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvfi: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwflags: i32) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub PopupItemMenu: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfi: *mut ::core::ffi::c_void, vx: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vy: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] PopupItemMenu: usize, #[cfg(feature = "Win32_System_Com")] pub Script: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -21427,19 +21324,19 @@ impl IShellFolderViewDual2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.FocusedItem)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelectItem(&self, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.SelectItem)(::windows_core::Interface::as_raw(self), pvfi, dwflags).ok() + pub unsafe fn SelectItem(&self, pvfi: *const ::windows_core::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.SelectItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvfi), dwflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: super::super::System::Variant::VARIANT, vy: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: P1, vy: P2) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), ::core::mem::transmute(vx), ::core::mem::transmute(vy), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), vx.into_param().abi(), vy.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -21512,19 +21409,19 @@ impl IShellFolderViewDual3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.FocusedItem)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelectItem(&self, pvfi: *const super::super::System::Variant::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.SelectItem)(::windows_core::Interface::as_raw(self), pvfi, dwflags).ok() + pub unsafe fn SelectItem(&self, pvfi: *const ::windows_core::VARIANT, dwflags: i32) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.base__.SelectItem)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvfi), dwflags).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: super::super::System::Variant::VARIANT, vy: super::super::System::Variant::VARIANT) -> ::windows_core::Result<::windows_core::BSTR> + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn PopupItemMenu(&self, pfi: P0, vx: P1, vy: P2) -> ::windows_core::Result<::windows_core::BSTR> where P0: ::windows_core::IntoParam, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), ::core::mem::transmute(vx), ::core::mem::transmute(vy), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.PopupItemMenu)(::windows_core::Interface::as_raw(self), pfi.into_param().abi(), vx.into_param().abi(), vy.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -22060,9 +21957,9 @@ impl IShellItem2 { { (::windows_core::Interface::vtable(self).Update)(::windows_core::Interface::as_raw(self), pbc.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetProperty(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetProperty(&self, key: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), key, &mut result__).from_abi(result__) } @@ -22133,9 +22030,9 @@ pub struct IShellItem2_Vtbl { pub Update: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbc: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Update: usize, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetProperty: usize, #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] pub GetCLSID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, key: *const PropertiesSystem::PROPERTYKEY, pclsid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, @@ -22698,10 +22595,11 @@ impl IShellLinkDual { { (::windows_core::Interface::vtable(self).SetIconLocation)(::windows_core::Interface::as_raw(self), bs.into_param().abi(), iicon).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, vwhere: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vwhere)).ok() + pub unsafe fn Save(&self, vwhere: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), vwhere.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -22724,10 +22622,7 @@ pub struct IShellLinkDual_Vtbl { pub Resolve: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fflags: i32) -> ::windows_core::HRESULT, pub GetIconLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbs: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, piicon: *mut i32) -> ::windows_core::HRESULT, pub SetIconLocation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bs: ::std::mem::MaybeUninit<::windows_core::BSTR>, iicon: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vwhere: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Save: usize, + pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vwhere: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -22806,10 +22701,11 @@ impl IShellLinkDual2 { { (::windows_core::Interface::vtable(self).base__.SetIconLocation)(::windows_core::Interface::as_raw(self), bs.into_param().abi(), iicon).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, vwhere: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vwhere)).ok() + pub unsafe fn Save(&self, vwhere: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.Save)(::windows_core::Interface::as_raw(self), vwhere.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -23149,16 +23045,15 @@ impl IShellNameSpace { { (::windows_core::Interface::vtable(self).SetSelectedItem)(::windows_core::Interface::as_raw(self), pitem.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Root(&self) -> ::windows_core::Result { + pub unsafe fn Root(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Root)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetRoot2(&self, var: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetRoot2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var)).ok() + pub unsafe fn SetRoot2(&self, var: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetRoot2)(::windows_core::Interface::as_raw(self), var.into_param().abi()).ok() } pub unsafe fn Depth(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -23211,10 +23106,11 @@ impl IShellNameSpace { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelectedItems)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Expand(&self, var: super::super::System::Variant::VARIANT, idepth: i32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Expand)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(var), idepth).ok() + pub unsafe fn Expand(&self, var: P0, idepth: i32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Expand)(::windows_core::Interface::as_raw(self), var.into_param().abi(), idepth).ok() } pub unsafe fn UnselectAll(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).UnselectAll)(::windows_core::Interface::as_raw(self)).ok() @@ -23235,14 +23131,8 @@ pub struct IShellNameSpace_Vtbl { pub SetSelectedItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pitem: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SetSelectedItem: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Root: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Root: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetRoot2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetRoot2: usize, + pub Root: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvar: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetRoot2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Depth: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pidepth: *mut i32) -> ::windows_core::HRESULT, pub SetDepth: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, idepth: i32) -> ::windows_core::HRESULT, pub Mode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pumode: *mut u32) -> ::windows_core::HRESULT, @@ -23259,10 +23149,7 @@ pub struct IShellNameSpace_Vtbl { pub SelectedItems: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppid: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] SelectedItems: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Expand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: super::super::System::Variant::VARIANT, idepth: i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Expand: usize, + pub Expand: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, var: ::std::mem::MaybeUninit<::windows_core::VARIANT>, idepth: i32) -> ::windows_core::HRESULT, pub UnselectAll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IShellPropSheetExt, IShellPropSheetExt_Vtbl, 0x000214e9_0000_0000_c000_000000000046); @@ -23381,9 +23268,7 @@ impl IShellUIHelper { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -23395,9 +23280,7 @@ impl IShellUIHelper { { (::windows_core::Interface::vtable(self).AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -23411,14 +23294,12 @@ impl IShellUIHelper { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -23427,33 +23308,25 @@ impl IShellUIHelper { { (::windows_core::Interface::vtable(self).ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -23464,37 +23337,16 @@ pub struct IShellUIHelper_Vtbl { pub ResetFirstBootMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ResetSafeMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub RefreshOfflineDesktop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddFavorite: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddFavorite: usize, + pub AddFavorite: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub AddChannel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddDesktopComponent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: ::std::mem::MaybeUninit<::windows_core::BSTR>, left: *const super::super::System::Variant::VARIANT, top: *const super::super::System::Variant::VARIANT, width: *const super::super::System::Variant::VARIANT, height: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddDesktopComponent: usize, + pub AddDesktopComponent: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: ::std::mem::MaybeUninit<::windows_core::BSTR>, left: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, top: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, width: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, height: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub IsSubscribed: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbool: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub NavigateAndFind: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, strquery: ::std::mem::MaybeUninit<::windows_core::BSTR>, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - NavigateAndFind: usize, + pub NavigateAndFind: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, strquery: ::std::mem::MaybeUninit<::windows_core::BSTR>, vartargetframe: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub ImportExportFavorites: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fimport: super::super::Foundation::VARIANT_BOOL, strimpexppath: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AutoCompleteSaveForm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, form: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AutoCompleteSaveForm: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AutoScan: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strsearch: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfailureurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AutoScan: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AutoCompleteAttach: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reserved: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AutoCompleteAttach: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ShowBrowserUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarin: *const super::super::System::Variant::VARIANT, pvarout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ShowBrowserUI: usize, + pub AutoCompleteSaveForm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, form: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AutoScan: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strsearch: ::std::mem::MaybeUninit<::windows_core::BSTR>, strfailureurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvartargetframe: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub AutoCompleteAttach: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, reserved: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub ShowBrowserUI: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarin: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -23516,9 +23368,7 @@ impl IShellUIHelper2 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -23530,9 +23380,7 @@ impl IShellUIHelper2 { { (::windows_core::Interface::vtable(self).base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -23546,14 +23394,12 @@ impl IShellUIHelper2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -23562,33 +23408,25 @@ impl IShellUIHelper2 { { (::windows_core::Interface::vtable(self).base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -23706,9 +23544,7 @@ impl IShellUIHelper3 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -23720,9 +23556,7 @@ impl IShellUIHelper3 { { (::windows_core::Interface::vtable(self).base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -23736,14 +23570,12 @@ impl IShellUIHelper3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -23752,33 +23584,25 @@ impl IShellUIHelper3 { { (::windows_core::Interface::vtable(self).base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -23871,14 +23695,12 @@ impl IShellUIHelper3 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -23929,10 +23751,7 @@ pub struct IShellUIHelper3_Vtbl { pub AddService: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub IsServiceInstalled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, verb: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdwresult: *mut u32) -> ::windows_core::HRESULT, pub InPrivateFilteringEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub AddToFavoritesBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - AddToFavoritesBar: usize, + pub AddToFavoritesBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, title: ::std::mem::MaybeUninit<::windows_core::BSTR>, r#type: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub BuildNewTabPage: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetRecentlyClosedVisible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetActivitiesVisible: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -23963,9 +23782,7 @@ impl IShellUIHelper4 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -23977,9 +23794,7 @@ impl IShellUIHelper4 { { (::windows_core::Interface::vtable(self).base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -23993,14 +23808,12 @@ impl IShellUIHelper4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -24009,33 +23822,25 @@ impl IShellUIHelper4 { { (::windows_core::Interface::vtable(self).base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -24128,14 +23933,12 @@ impl IShellUIHelper4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -24184,9 +23987,7 @@ impl IShellUIHelper4 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -24194,22 +23995,19 @@ impl IShellUIHelper4 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -24223,15 +24021,13 @@ impl IShellUIHelper4 { { (::windows_core::Interface::vtable(self).msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -24239,27 +24035,26 @@ impl IShellUIHelper4 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -24289,40 +24084,19 @@ pub struct IShellUIHelper4_Vtbl { pub base__: IShellUIHelper3_Vtbl, pub msIsSiteMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfsitemode: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub msSiteModeShowThumbBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeAddThumbBarButton: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbuttonid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeAddThumbBarButton: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeUpdateThumbBarButton: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buttonid: super::super::System::Variant::VARIANT, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeUpdateThumbBarButton: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeSetIconOverlay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeSetIconOverlay: usize, + pub msSiteModeAddThumbBarButton: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarbuttonid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub msSiteModeUpdateThumbBarButton: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, buttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, fenabled: super::super::Foundation::VARIANT_BOOL, fvisible: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, + pub msSiteModeSetIconOverlay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, iconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvardescription: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msSiteModeClearIconOverlay: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msAddSiteMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msSiteModeCreateJumpList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrheader: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeAddJumpListItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstractionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstriconuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeAddJumpListItem: usize, + pub msSiteModeAddJumpListItem: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrname: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstractionuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstriconuri: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarwindowtype: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msSiteModeClearJumpList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msSiteModeShowJumpList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeAddButtonStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarstyleid: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeAddButtonStyle: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msSiteModeShowButtonStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msSiteModeShowButtonStyle: usize, + pub msSiteModeAddButtonStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uibuttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, bstriconurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrtooltip: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvarstyleid: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub msSiteModeShowButtonStyle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, uibuttonid: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uistyleid: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msSiteModeActivate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msIsSiteModeFirstRun: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fpreservestate: super::super::Foundation::VARIANT_BOOL, puifirstrun: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msIsSiteModeFirstRun: usize, + pub msIsSiteModeFirstRun: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fpreservestate: super::super::Foundation::VARIANT_BOOL, puifirstrun: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msAddTrackingProtectionList: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrfiltername: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub msTrackingProtectionEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub msActiveXFilteringEnabled: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pfenabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -24347,9 +24121,7 @@ impl IShellUIHelper5 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -24361,9 +24133,7 @@ impl IShellUIHelper5 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -24377,14 +24147,12 @@ impl IShellUIHelper5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -24393,33 +24161,25 @@ impl IShellUIHelper5 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -24512,14 +24272,12 @@ impl IShellUIHelper5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -24568,9 +24326,7 @@ impl IShellUIHelper5 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -24578,22 +24334,19 @@ impl IShellUIHelper5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -24607,15 +24360,13 @@ impl IShellUIHelper5 { { (::windows_core::Interface::vtable(self).base__.msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -24623,27 +24374,26 @@ impl IShellUIHelper5 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -24665,9 +24415,7 @@ impl IShellUIHelper5 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.msActiveXFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result + pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -24701,10 +24449,7 @@ impl IShellUIHelper5 { #[doc(hidden)] pub struct IShellUIHelper5_Vtbl { pub base__: IShellUIHelper4_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msProvisionNetworks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovisioningxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, puiresult: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msProvisionNetworks: usize, + pub msProvisionNetworks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrprovisioningxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, puiresult: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msReportSafeUrl: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msSiteModeRefreshBadge: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msSiteModeClearBadge: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -24732,9 +24477,7 @@ impl IShellUIHelper6 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -24746,9 +24489,7 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -24762,14 +24503,12 @@ impl IShellUIHelper6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -24778,33 +24517,25 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -24897,14 +24628,12 @@ impl IShellUIHelper6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -24953,9 +24682,7 @@ impl IShellUIHelper6 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -24963,22 +24690,19 @@ impl IShellUIHelper6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -24992,15 +24716,13 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -25008,27 +24730,26 @@ impl IShellUIHelper6 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -25050,9 +24771,7 @@ impl IShellUIHelper6 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.msActiveXFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result + pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -25083,15 +24802,21 @@ impl IShellUIHelper6 { pub unsafe fn msStopPeriodicTileUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msStopPeriodicTileUpdate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msClearTile(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msClearTile)(::windows_core::Interface::as_raw(self)).ok() @@ -25102,9 +24827,7 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).msEnableTileNotificationQueue)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result { + pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).msPinnedSiteState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -25126,15 +24849,15 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).msEnableTileNotificationQueueForSquare310x310)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: P3, expirationtime: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(expirationtime)).ok() + (::windows_core::Interface::vtable(self).msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), starttime.into_param().abi(), expirationtime.into_param().abi()).ok() } pub unsafe fn msRemoveScheduledTileNotification(&self, bstrnotificationid: P0) -> ::windows_core::Result<()> where @@ -25142,13 +24865,13 @@ impl IShellUIHelper6 { { (::windows_core::Interface::vtable(self).msRemoveScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + (::windows_core::Interface::vtable(self).msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msStopPeriodicBadgeUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).msStopPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self)).ok() @@ -25163,32 +24886,17 @@ impl IShellUIHelper6 { pub struct IShellUIHelper6_Vtbl { pub base__: IShellUIHelper5_Vtbl, pub msStopPeriodicTileUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msStartPeriodicTileUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msStartPeriodicTileUpdate: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msStartPeriodicTileUpdateBatch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msStartPeriodicTileUpdateBatch: usize, + pub msStartPeriodicTileUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguris: ::std::mem::MaybeUninit<::windows_core::VARIANT>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub msStartPeriodicTileUpdateBatch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguris: ::std::mem::MaybeUninit<::windows_core::VARIANT>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msClearTile: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msEnableTileNotificationQueue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msPinnedSiteState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsitestate: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msPinnedSiteState: usize, + pub msPinnedSiteState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarsitestate: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msEnableTileNotificationQueueForSquare150x150: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub msEnableTileNotificationQueueForWide310x150: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub msEnableTileNotificationQueueForSquare310x310: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fchange: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msScheduledTileNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrnotificationxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationtag: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msScheduledTileNotification: usize, + pub msScheduledTileNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrnotificationxml: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationid: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrnotificationtag: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, expirationtime: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msRemoveScheduledTileNotification: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrnotificationid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub msStartPeriodicBadgeUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguri: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - msStartPeriodicBadgeUpdate: usize, + pub msStartPeriodicBadgeUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pollinguri: ::std::mem::MaybeUninit<::windows_core::BSTR>, starttime: ::std::mem::MaybeUninit<::windows_core::VARIANT>, uiupdaterecurrence: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub msStopPeriodicBadgeUpdate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub msLaunchInternetOptions: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } @@ -25212,9 +24920,7 @@ impl IShellUIHelper7 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -25226,9 +24932,7 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -25242,14 +24946,12 @@ impl IShellUIHelper7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -25258,33 +24960,25 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -25377,14 +25071,12 @@ impl IShellUIHelper7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -25433,9 +25125,7 @@ impl IShellUIHelper7 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -25443,22 +25133,19 @@ impl IShellUIHelper7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -25472,15 +25159,13 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -25488,27 +25173,26 @@ impl IShellUIHelper7 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -25530,9 +25214,7 @@ impl IShellUIHelper7 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.msActiveXFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result + pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -25563,15 +25245,21 @@ impl IShellUIHelper7 { pub unsafe fn msStopPeriodicTileUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msStopPeriodicTileUpdate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msClearTile(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msClearTile)(::windows_core::Interface::as_raw(self)).ok() @@ -25582,9 +25270,7 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.msEnableTileNotificationQueue)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result { + pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.msPinnedSiteState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -25606,15 +25292,15 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.msEnableTileNotificationQueueForSquare310x310)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: P3, expirationtime: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(expirationtime)).ok() + (::windows_core::Interface::vtable(self).base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), starttime.into_param().abi(), expirationtime.into_param().abi()).ok() } pub unsafe fn msRemoveScheduledTileNotification(&self, bstrnotificationid: P0) -> ::windows_core::Result<()> where @@ -25622,13 +25308,13 @@ impl IShellUIHelper7 { { (::windows_core::Interface::vtable(self).base__.msRemoveScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + (::windows_core::Interface::vtable(self).base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msStopPeriodicBadgeUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.msStopPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self)).ok() @@ -25730,9 +25416,7 @@ impl IShellUIHelper8 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -25744,9 +25428,7 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -25760,14 +25442,12 @@ impl IShellUIHelper8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -25776,33 +25456,25 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -25895,14 +25567,12 @@ impl IShellUIHelper8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -25951,9 +25621,7 @@ impl IShellUIHelper8 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -25961,22 +25629,19 @@ impl IShellUIHelper8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -25990,15 +25655,13 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -26006,27 +25669,26 @@ impl IShellUIHelper8 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -26048,9 +25710,7 @@ impl IShellUIHelper8 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.msActiveXFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result + pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -26081,15 +25741,21 @@ impl IShellUIHelper8 { pub unsafe fn msStopPeriodicTileUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msStopPeriodicTileUpdate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msClearTile(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msClearTile)(::windows_core::Interface::as_raw(self)).ok() @@ -26100,9 +25766,7 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.msEnableTileNotificationQueue)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result { + pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.msPinnedSiteState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -26124,15 +25788,15 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.msEnableTileNotificationQueueForSquare310x310)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: P3, expirationtime: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(expirationtime)).ok() + (::windows_core::Interface::vtable(self).base__.base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), starttime.into_param().abi(), expirationtime.into_param().abi()).ok() } pub unsafe fn msRemoveScheduledTileNotification(&self, bstrnotificationid: P0) -> ::windows_core::Result<()> where @@ -26140,13 +25804,13 @@ impl IShellUIHelper8 { { (::windows_core::Interface::vtable(self).base__.base__.msRemoveScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + (::windows_core::Interface::vtable(self).base__.base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msStopPeriodicBadgeUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.msStopPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self)).ok() @@ -26274,9 +25938,7 @@ impl IShellUIHelper9 { pub unsafe fn RefreshOfflineDesktop(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.RefreshOfflineDesktop)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddFavorite(&self, url: P0, title: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -26288,9 +25950,7 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.AddChannel)(::windows_core::Interface::as_raw(self), url.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const super::super::System::Variant::VARIANT>, top: ::core::option::Option<*const super::super::System::Variant::VARIANT>, width: ::core::option::Option<*const super::super::System::Variant::VARIANT>, height: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AddDesktopComponent(&self, url: P0, r#type: P1, left: ::core::option::Option<*const ::windows_core::VARIANT>, top: ::core::option::Option<*const ::windows_core::VARIANT>, width: ::core::option::Option<*const ::windows_core::VARIANT>, height: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -26304,14 +25964,12 @@ impl IShellUIHelper9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.IsSubscribed)(::windows_core::Interface::as_raw(self), url.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn NavigateAndFind(&self, url: P0, strquery: P1, vartargetframe: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), vartargetframe).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.NavigateAndFind)(::windows_core::Interface::as_raw(self), url.into_param().abi(), strquery.into_param().abi(), ::core::mem::transmute(vartargetframe)).ok() } pub unsafe fn ImportExportFavorites(&self, fimport: P0, strimpexppath: P1) -> ::windows_core::Result<()> where @@ -26320,33 +25978,25 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.ImportExportFavorites)(::windows_core::Interface::as_raw(self), fimport.into_param().abi(), strimpexppath.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteSaveForm(&self, form: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.AutoCompleteSaveForm)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(form.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn AutoScan(&self, strsearch: P0, strfailureurl: P1, pvartargetframe: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.AutoScan)(::windows_core::Interface::as_raw(self), strsearch.into_param().abi(), strfailureurl.into_param().abi(), ::core::mem::transmute(pvartargetframe.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn AutoCompleteAttach(&self, reserved: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.AutoCompleteAttach)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(reserved.unwrap_or(::std::ptr::null()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result + pub unsafe fn ShowBrowserUI(&self, bstrname: P0, pvarin: *const ::windows_core::VARIANT) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), pvarin, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.base__.base__.ShowBrowserUI)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), ::core::mem::transmute(pvarin), &mut result__).from_abi(result__) } pub unsafe fn AddSearchProvider(&self, url: P0) -> ::windows_core::Result<()> where @@ -26439,14 +26089,12 @@ impl IShellUIHelper9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.InPrivateFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn AddToFavoritesBar(&self, url: P0, title: P1, r#type: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), r#type).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.AddToFavoritesBar)(::windows_core::Interface::as_raw(self), url.into_param().abi(), title.into_param().abi(), ::core::mem::transmute(r#type)).ok() } pub unsafe fn BuildNewTabPage(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.base__.BuildNewTabPage)(::windows_core::Interface::as_raw(self)).ok() @@ -26495,9 +26143,7 @@ impl IShellUIHelper9 { pub unsafe fn msSiteModeShowThumbBar(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeShowThumbBar)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddThumbBarButton(&self, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, @@ -26505,22 +26151,19 @@ impl IShellUIHelper9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeAddThumbBarButton)(::windows_core::Interface::as_raw(self), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: super::super::System::Variant::VARIANT, fenabled: P0, fvisible: P1) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeUpdateThumbBarButton(&self, buttonid: P0, fenabled: P1, fvisible: P2) -> ::windows_core::Result<()> where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam, + P2: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(buttonid), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeUpdateThumbBarButton)(::windows_core::Interface::as_raw(self), buttonid.into_param().abi(), fenabled.into_param().abi(), fvisible.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeSetIconOverlay(&self, iconurl: P0, pvardescription: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), pvardescription).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeSetIconOverlay)(::windows_core::Interface::as_raw(self), iconurl.into_param().abi(), ::core::mem::transmute(pvardescription)).ok() } pub unsafe fn msSiteModeClearIconOverlay(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeClearIconOverlay)(::windows_core::Interface::as_raw(self)).ok() @@ -26534,15 +26177,13 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeCreateJumpList)(::windows_core::Interface::as_raw(self), bstrheader.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msSiteModeAddJumpListItem(&self, bstrname: P0, bstractionuri: P1, bstriconuri: P2, pvarwindowtype: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), pvarwindowtype).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeAddJumpListItem)(::windows_core::Interface::as_raw(self), bstrname.into_param().abi(), bstractionuri.into_param().abi(), bstriconuri.into_param().abi(), ::core::mem::transmute(pvarwindowtype)).ok() } pub unsafe fn msSiteModeClearJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeClearJumpList)(::windows_core::Interface::as_raw(self)).ok() @@ -26550,27 +26191,26 @@ impl IShellUIHelper9 { pub unsafe fn msSiteModeShowJumpList(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeShowJumpList)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, bstriconurl: P0, bstrtooltip: P1) -> ::windows_core::Result + pub unsafe fn msSiteModeAddButtonStyle(&self, uibuttonid: P0, bstriconurl: P1, bstrtooltip: P2) -> ::windows_core::Result<::windows_core::VARIANT> where - P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, + P2: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeAddButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), bstriconurl.into_param().abi(), bstrtooltip.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: super::super::System::Variant::VARIANT, uistyleid: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(uibuttonid), ::core::mem::transmute(uistyleid)).ok() + pub unsafe fn msSiteModeShowButtonStyle(&self, uibuttonid: P0, uistyleid: P1) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeShowButtonStyle)(::windows_core::Interface::as_raw(self), uibuttonid.into_param().abi(), uistyleid.into_param().abi()).ok() } pub unsafe fn msSiteModeActivate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msSiteModeActivate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result + pub unsafe fn msIsSiteModeFirstRun(&self, fpreservestate: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -26592,9 +26232,7 @@ impl IShellUIHelper9 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.base__.base__.msActiveXFilteringEnabled)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result + pub unsafe fn msProvisionNetworks(&self, bstrprovisioningxml: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -26625,15 +26263,21 @@ impl IShellUIHelper9 { pub unsafe fn msStopPeriodicTileUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msStopPeriodicTileUpdate)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdate(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicTileUpdate)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: super::super::System::Variant::VARIANT, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pollinguris), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + pub unsafe fn msStartPeriodicTileUpdateBatch(&self, pollinguris: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicTileUpdateBatch)(::windows_core::Interface::as_raw(self), pollinguris.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msClearTile(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msClearTile)(::windows_core::Interface::as_raw(self)).ok() @@ -26644,9 +26288,7 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.msEnableTileNotificationQueue)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result { + pub unsafe fn msPinnedSiteState(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.base__.base__.msPinnedSiteState)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -26668,15 +26310,15 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.msEnableTileNotificationQueueForSquare310x310)(::windows_core::Interface::as_raw(self), fchange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: super::super::System::Variant::VARIANT, expirationtime: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msScheduledTileNotification(&self, bstrnotificationxml: P0, bstrnotificationid: P1, bstrnotificationtag: P2, starttime: P3, expirationtime: P4) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, P1: ::windows_core::IntoParam<::windows_core::BSTR>, P2: ::windows_core::IntoParam<::windows_core::BSTR>, + P3: ::windows_core::IntoParam<::windows_core::VARIANT>, + P4: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(expirationtime)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.msScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationxml.into_param().abi(), bstrnotificationid.into_param().abi(), bstrnotificationtag.into_param().abi(), starttime.into_param().abi(), expirationtime.into_param().abi()).ok() } pub unsafe fn msRemoveScheduledTileNotification(&self, bstrnotificationid: P0) -> ::windows_core::Result<()> where @@ -26684,13 +26326,13 @@ impl IShellUIHelper9 { { (::windows_core::Interface::vtable(self).base__.base__.base__.msRemoveScheduledTileNotification)(::windows_core::Interface::as_raw(self), bstrnotificationid.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: super::super::System::Variant::VARIANT, uiupdaterecurrence: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn msStartPeriodicBadgeUpdate(&self, pollinguri: P0, starttime: P1, uiupdaterecurrence: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), ::core::mem::transmute(starttime), ::core::mem::transmute(uiupdaterecurrence)).ok() + (::windows_core::Interface::vtable(self).base__.base__.base__.msStartPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self), pollinguri.into_param().abi(), starttime.into_param().abi(), uiupdaterecurrence.into_param().abi()).ok() } pub unsafe fn msStopPeriodicBadgeUpdate(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.base__.msStopPeriodicBadgeUpdate)(::windows_core::Interface::as_raw(self)).ok() @@ -27164,11 +26806,14 @@ impl IShellWindows { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Count)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, index: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, index: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(index), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), index.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown> { let mut result__ = ::std::mem::zeroed(); @@ -27183,19 +26828,15 @@ impl IShellWindows { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Register)(::windows_core::Interface::as_raw(self), pid.into_param().abi(), hwnd, swclass, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn RegisterPending(&self, lthreadid: i32, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants) -> ::windows_core::Result { + pub unsafe fn RegisterPending(&self, lthreadid: i32, pvarloc: *const ::windows_core::VARIANT, pvarlocroot: *const ::windows_core::VARIANT, swclass: ShellWindowTypeConstants) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).RegisterPending)(::windows_core::Interface::as_raw(self), lthreadid, pvarloc, pvarlocroot, swclass, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).RegisterPending)(::windows_core::Interface::as_raw(self), lthreadid, ::core::mem::transmute(pvarloc), ::core::mem::transmute(pvarlocroot), swclass, &mut result__).from_abi(result__) } pub unsafe fn Revoke(&self, lcookie: i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Revoke)(::windows_core::Interface::as_raw(self), lcookie).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnNavigate(&self, lcookie: i32, pvarloc: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnNavigate)(::windows_core::Interface::as_raw(self), lcookie, pvarloc).ok() + pub unsafe fn OnNavigate(&self, lcookie: i32, pvarloc: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).OnNavigate)(::windows_core::Interface::as_raw(self), lcookie, ::core::mem::transmute(pvarloc)).ok() } pub unsafe fn OnActivated(&self, lcookie: i32, factive: P0) -> ::windows_core::Result<()> where @@ -27203,10 +26844,10 @@ impl IShellWindows { { (::windows_core::Interface::vtable(self).OnActivated)(::windows_core::Interface::as_raw(self), lcookie, factive.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindWindowSW(&self, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).FindWindowSW)(::windows_core::Interface::as_raw(self), pvarloc, pvarlocroot, swclass, phwnd, swfwoptions, ::core::mem::transmute(ppdispout)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn FindWindowSW(&self, pvarloc: *const ::windows_core::VARIANT, pvarlocroot: *const ::windows_core::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut ::core::option::Option) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).FindWindowSW)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarloc), ::core::mem::transmute(pvarlocroot), swclass, phwnd, swfwoptions, ::core::mem::transmute(ppdispout)).ok() } pub unsafe fn OnCreated(&self, lcookie: i32, punk: P0) -> ::windows_core::Result<()> where @@ -27227,28 +26868,22 @@ impl IShellWindows { pub struct IShellWindows_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: super::super::System::Variant::VARIANT, folder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: ::std::mem::MaybeUninit<::windows_core::VARIANT>, folder: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppunk: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Register: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pid: *mut ::core::ffi::c_void, hwnd: i32, swclass: ShellWindowTypeConstants, plcookie: *mut i32) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Register: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub RegisterPending: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lthreadid: i32, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, plcookie: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RegisterPending: usize, + pub RegisterPending: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lthreadid: i32, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarlocroot: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, swclass: ShellWindowTypeConstants, plcookie: *mut i32) -> ::windows_core::HRESULT, pub Revoke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcookie: i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnNavigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcookie: i32, pvarloc: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnNavigate: usize, + pub OnNavigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcookie: i32, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub OnActivated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcookie: i32, factive: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindWindowSW: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarloc: *const super::super::System::Variant::VARIANT, pvarlocroot: *const super::super::System::Variant::VARIANT, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub FindWindowSW: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarloc: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarlocroot: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, swclass: ShellWindowTypeConstants, phwnd: *mut i32, swfwoptions: ShellWindowFindWindowOptions, ppdispout: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] FindWindowSW: usize, pub OnCreated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, lcookie: i32, punk: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ProcessAttachDetach: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fattach: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -27580,9 +27215,9 @@ pub struct ISuspensionDependencyManager_Vtbl { ::windows_core::imp::com_interface!(ISyncMgrConflict, ISyncMgrConflict_Vtbl, 0x9c204249_c443_4ba4_85ed_c972681db137); ::windows_core::imp::interface_hierarchy!(ISyncMgrConflict, ::windows_core::IUnknown); impl ISyncMgrConflict { - #[doc = "Required features: `\"Win32_System_Com_StructuredStorage\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Shell_PropertiesSystem\"`"] - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub unsafe fn GetProperty(&self, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_UI_Shell_PropertiesSystem\"`"] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub unsafe fn GetProperty(&self, propkey: *const PropertiesSystem::PROPERTYKEY) -> ::windows_core::Result<::windows_core::PROPVARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetProperty)(::windows_core::Interface::as_raw(self), propkey, &mut result__).from_abi(result__) } @@ -27614,9 +27249,9 @@ impl ISyncMgrConflict { #[doc(hidden)] pub struct ISyncMgrConflict_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut super::super::System::Com::StructuredStorage::PROPVARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Variant", feature = "Win32_UI_Shell_PropertiesSystem")))] + #[cfg(feature = "Win32_UI_Shell_PropertiesSystem")] + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propkey: *const PropertiesSystem::PROPERTYKEY, ppropvar: *mut ::std::mem::MaybeUninit<::windows_core::PROPVARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_UI_Shell_PropertiesSystem"))] GetProperty: usize, #[cfg(feature = "Win32_System_Com")] pub GetConflictIdInfo: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pconflictidinfo: *mut SYNCMGR_CONFLICT_ID_INFO) -> ::windows_core::HRESULT, @@ -30184,9 +29819,7 @@ impl IWebBrowser { pub unsafe fn GoSearch(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).GoSearch)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const super::super::System::Variant::VARIANT>, targetframename: ::core::option::Option<*const super::super::System::Variant::VARIANT>, postdata: ::core::option::Option<*const super::super::System::Variant::VARIANT>, headers: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const ::windows_core::VARIANT>, targetframename: ::core::option::Option<*const ::windows_core::VARIANT>, postdata: ::core::option::Option<*const ::windows_core::VARIANT>, headers: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -30195,9 +29828,7 @@ impl IWebBrowser { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Refresh2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(level.unwrap_or(::std::ptr::null()))).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { @@ -30285,15 +29916,9 @@ pub struct IWebBrowser_Vtbl { pub GoForward: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GoHome: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GoSearch: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Navigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Navigate: usize, + pub Navigate: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: ::std::mem::MaybeUninit<::windows_core::BSTR>, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, targetframename: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, postdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, headers: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Refresh: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Refresh2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, level: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Refresh2: usize, + pub Refresh2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, level: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Stop: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Application: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppdisp: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -30348,9 +29973,7 @@ impl IWebBrowser2 { pub unsafe fn GoSearch(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.GoSearch)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const super::super::System::Variant::VARIANT>, targetframename: ::core::option::Option<*const super::super::System::Variant::VARIANT>, postdata: ::core::option::Option<*const super::super::System::Variant::VARIANT>, headers: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const ::windows_core::VARIANT>, targetframename: ::core::option::Option<*const ::windows_core::VARIANT>, postdata: ::core::option::Option<*const ::windows_core::VARIANT>, headers: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -30359,9 +29982,7 @@ impl IWebBrowser2 { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.base__.Refresh2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(level.unwrap_or(::std::ptr::null()))).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { @@ -30445,17 +30066,14 @@ impl IWebBrowser2 { pub unsafe fn ClientToWindow(&self, pcx: *mut i32, pcy: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.ClientToWindow)(::windows_core::Interface::as_raw(self), pcx, pcy).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutProperty(&self, property: P0, vtvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutProperty(&self, property: P0, vtvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).base__.PutProperty)(::windows_core::Interface::as_raw(self), property.into_param().abi(), ::core::mem::transmute(vtvalue)).ok() + (::windows_core::Interface::vtable(self).base__.PutProperty)(::windows_core::Interface::as_raw(self), property.into_param().abi(), vtvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, property: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, property: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -30535,10 +30153,8 @@ impl IWebBrowser2 { { (::windows_core::Interface::vtable(self).base__.SetFullScreen)(::windows_core::Interface::as_raw(self), bfullscreen.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Navigate2(&self, url: *const super::super::System::Variant::VARIANT, flags: ::core::option::Option<*const super::super::System::Variant::VARIANT>, targetframename: ::core::option::Option<*const super::super::System::Variant::VARIANT>, postdata: ::core::option::Option<*const super::super::System::Variant::VARIANT>, headers: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Navigate2)(::windows_core::Interface::as_raw(self), url, ::core::mem::transmute(flags.unwrap_or(::std::ptr::null())), ::core::mem::transmute(targetframename.unwrap_or(::std::ptr::null())), ::core::mem::transmute(postdata.unwrap_or(::std::ptr::null())), ::core::mem::transmute(headers.unwrap_or(::std::ptr::null()))).ok() + pub unsafe fn Navigate2(&self, url: *const ::windows_core::VARIANT, flags: ::core::option::Option<*const ::windows_core::VARIANT>, targetframename: ::core::option::Option<*const ::windows_core::VARIANT>, postdata: ::core::option::Option<*const ::windows_core::VARIANT>, headers: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).Navigate2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(url), ::core::mem::transmute(flags.unwrap_or(::std::ptr::null())), ::core::mem::transmute(targetframename.unwrap_or(::std::ptr::null())), ::core::mem::transmute(postdata.unwrap_or(::std::ptr::null())), ::core::mem::transmute(headers.unwrap_or(::std::ptr::null()))).ok() } #[doc = "Required features: `\"Win32_System_Ole\"`"] #[cfg(feature = "Win32_System_Ole")] @@ -30546,15 +30162,13 @@ impl IWebBrowser2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).QueryStatusWB)(::windows_core::Interface::as_raw(self), cmdid, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ExecWB(&self, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: ::core::option::Option<*const super::super::System::Variant::VARIANT>, pvaout: ::core::option::Option<*mut super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn ExecWB(&self, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: ::core::option::Option<*const ::windows_core::VARIANT>, pvaout: ::core::option::Option<*mut ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ExecWB)(::windows_core::Interface::as_raw(self), cmdid, cmdexecopt, ::core::mem::transmute(pvain.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pvaout.unwrap_or(::std::ptr::null_mut()))).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ShowBrowserBar(&self, pvaclsid: *const super::super::System::Variant::VARIANT, pvarshow: ::core::option::Option<*const super::super::System::Variant::VARIANT>, pvarsize: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ShowBrowserBar)(::windows_core::Interface::as_raw(self), pvaclsid, ::core::mem::transmute(pvarshow.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pvarsize.unwrap_or(::std::ptr::null()))).ok() + pub unsafe fn ShowBrowserBar(&self, pvaclsid: *const ::windows_core::VARIANT, pvarshow: ::core::option::Option<*const ::windows_core::VARIANT>, pvarsize: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).ShowBrowserBar)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvaclsid), ::core::mem::transmute(pvarshow.unwrap_or(::std::ptr::null())), ::core::mem::transmute(pvarsize.unwrap_or(::std::ptr::null()))).ok() } #[doc = "Required features: `\"Win32_System_Ole\"`"] #[cfg(feature = "Win32_System_Ole")] @@ -30638,22 +30252,16 @@ impl IWebBrowser2 { #[doc(hidden)] pub struct IWebBrowser2_Vtbl { pub base__: IWebBrowserApp_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Navigate2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: *const super::super::System::Variant::VARIANT, flags: *const super::super::System::Variant::VARIANT, targetframename: *const super::super::System::Variant::VARIANT, postdata: *const super::super::System::Variant::VARIANT, headers: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Navigate2: usize, + pub Navigate2: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, url: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, flags: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, targetframename: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, postdata: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, headers: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub QueryStatusWB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cmdid: super::super::System::Ole::OLECMDID, pcmdf: *mut super::super::System::Ole::OLECMDF) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] QueryStatusWB: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ExecWB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const super::super::System::Variant::VARIANT, pvaout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Ole")] + pub ExecWB: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cmdid: super::super::System::Ole::OLECMDID, cmdexecopt: super::super::System::Ole::OLECMDEXECOPT, pvain: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvaout: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Ole"))] ExecWB: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ShowBrowserBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaclsid: *const super::super::System::Variant::VARIANT, pvarshow: *const super::super::System::Variant::VARIANT, pvarsize: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ShowBrowserBar: usize, + pub ShowBrowserBar: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvaclsid: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarshow: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>, pvarsize: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Ole")] pub ReadyState: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plreadystate: *mut super::super::System::Ole::READYSTATE) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Ole"))] @@ -30696,9 +30304,7 @@ impl IWebBrowserApp { pub unsafe fn GoSearch(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.GoSearch)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const super::super::System::Variant::VARIANT>, targetframename: ::core::option::Option<*const super::super::System::Variant::VARIANT>, postdata: ::core::option::Option<*const super::super::System::Variant::VARIANT>, headers: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> + pub unsafe fn Navigate(&self, url: P0, flags: ::core::option::Option<*const ::windows_core::VARIANT>, targetframename: ::core::option::Option<*const ::windows_core::VARIANT>, postdata: ::core::option::Option<*const ::windows_core::VARIANT>, headers: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -30707,9 +30313,7 @@ impl IWebBrowserApp { pub unsafe fn Refresh(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Refresh)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const super::super::System::Variant::VARIANT>) -> ::windows_core::Result<()> { + pub unsafe fn Refresh2(&self, level: ::core::option::Option<*const ::windows_core::VARIANT>) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Refresh2)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(level.unwrap_or(::std::ptr::null()))).ok() } pub unsafe fn Stop(&self) -> ::windows_core::Result<()> { @@ -30793,17 +30397,14 @@ impl IWebBrowserApp { pub unsafe fn ClientToWindow(&self, pcx: *mut i32, pcy: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).ClientToWindow)(::windows_core::Interface::as_raw(self), pcx, pcy).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PutProperty(&self, property: P0, vtvalue: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn PutProperty(&self, property: P0, vtvalue: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), property.into_param().abi(), ::core::mem::transmute(vtvalue)).ok() + (::windows_core::Interface::vtable(self).PutProperty)(::windows_core::Interface::as_raw(self), property.into_param().abi(), vtvalue.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetProperty(&self, property: P0) -> ::windows_core::Result + pub unsafe fn GetProperty(&self, property: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -30891,14 +30492,8 @@ pub struct IWebBrowserApp_Vtbl { pub base__: IWebBrowser_Vtbl, pub Quit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub ClientToWindow: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pcx: *mut i32, pcy: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PutProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvtvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetProperty: usize, + pub PutProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, vtvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, property: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvtvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub HWND: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phwnd: *mut super::super::Foundation::SHANDLE_PTR) -> ::windows_core::HRESULT, pub FullName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fullname: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -30986,17 +30581,13 @@ impl IWebWizardHost { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Caption)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), pvproperty).ok() + (::windows_core::Interface::vtable(self).put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(pvproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -31029,14 +30620,8 @@ pub struct IWebWizardHost_Vtbl { pub Cancel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub SetCaption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrcaption: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Caption: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrcaption: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - put_Property: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - get_Property: usize, + pub put_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub get_Property: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvproperty: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SetWizardButtons: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vfenableback: super::super::Foundation::VARIANT_BOOL, vfenablenext: super::super::Foundation::VARIANT_BOOL, vflastpage: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetHeaderText: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrheadertitle: ::std::mem::MaybeUninit<::windows_core::BSTR>, bstrheadersubtitle: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } @@ -31070,17 +30655,13 @@ impl IWebWizardHost2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.Caption)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn put_Property(&self, bstrpropertyname: P0, pvproperty: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { - (::windows_core::Interface::vtable(self).base__.put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), pvproperty).ok() + (::windows_core::Interface::vtable(self).base__.put_Property)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(pvproperty)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result + pub unsafe fn get_Property(&self, bstrpropertyname: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { diff --git a/crates/libs/windows/src/Windows/Win32/UI/TabletPC/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/TabletPC/impl.rs index c740f92081..578536855c 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/TabletPC/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/TabletPC/impl.rs @@ -254,12 +254,12 @@ impl IHandwrittenTextInsertion_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInk_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInk {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInk_Vtbl { pub const fn new, Impl: IInk_Impl, const OFFSET: isize>() -> IInk_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -268,8 +268,8 @@ impl IInk_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IInkCollector_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn hWnd(&self) -> ::windows_core::Result; fn SethWnd(&self, newwindow: isize) -> ::windows_core::Result<()>; @@ -288,8 +288,8 @@ pub trait IInkCollector_Impl: Sized + super::super::System::Com::IDispatch_Impl fn SetCollectionMode(&self, mode: InkCollectionMode) -> ::windows_core::Result<()>; fn DynamicRendering(&self) -> ::windows_core::Result; fn SetDynamicRendering(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn DesiredPacketDescription(&self) -> ::windows_core::Result; - fn SetDesiredPacketDescription(&self, packetguids: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDesiredPacketDescription(&self, packetguids: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MouseIcon(&self) -> ::windows_core::Result; fn SetMouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; fn putref_MouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; @@ -312,9 +312,9 @@ pub trait IInkCollector_Impl: Sized + super::super::System::Com::IDispatch_Impl fn GetEventInterest(&self, eventid: InkCollectorEventInterest) -> ::windows_core::Result; fn SetEventInterest(&self, eventid: InkCollectorEventInterest, listen: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IInkCollector {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IInkCollector_Vtbl { pub const fn new, Impl: IInkCollector_Impl, const OFFSET: isize>() -> IInkCollector_Vtbl { unsafe extern "system" fn hWnd, Impl: IInkCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentwindow: *mut isize) -> ::windows_core::HRESULT { @@ -456,7 +456,7 @@ impl IInkCollector_Vtbl { let this = (*this).get_impl(); this.SetDynamicRendering(::core::mem::transmute_copy(&enabled)).into() } - unsafe extern "system" fn DesiredPacketDescription, Impl: IInkCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DesiredPacketDescription, Impl: IInkCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DesiredPacketDescription() { @@ -467,7 +467,7 @@ impl IInkCollector_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkCollector_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDesiredPacketDescription(::core::mem::transmute(&packetguids)).into() @@ -679,8 +679,8 @@ impl IInkCollector_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkCursor_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Id(&self) -> ::windows_core::Result; @@ -690,9 +690,9 @@ pub trait IInkCursor_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Tablet(&self) -> ::windows_core::Result; fn Buttons(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkCursor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkCursor_Vtbl { pub const fn new, Impl: IInkCursor_Impl, const OFFSET: isize>() -> IInkCursor_Vtbl { unsafe extern "system" fn Name, Impl: IInkCursor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -781,16 +781,16 @@ impl IInkCursor_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkCursorButton_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn State(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkCursorButton {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkCursorButton_Vtbl { pub const fn new, Impl: IInkCursorButton_Impl, const OFFSET: isize>() -> IInkCursorButton_Vtbl { unsafe extern "system" fn Name, Impl: IInkCursorButton_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -837,16 +837,16 @@ impl IInkCursorButton_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkCursorButtons_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Item(&self, identifier: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, identifier: &::windows_core::VARIANT) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkCursorButtons {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkCursorButtons_Vtbl { pub const fn new, Impl: IInkCursorButtons_Impl, const OFFSET: isize>() -> IInkCursorButtons_Vtbl { unsafe extern "system" fn Count, Impl: IInkCursorButtons_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -871,7 +871,7 @@ impl IInkCursorButtons_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: IInkCursorButtons_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, button: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IInkCursorButtons_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, button: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&identifier)) { @@ -893,16 +893,16 @@ impl IInkCursorButtons_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkCursors_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkCursors {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkCursors_Vtbl { pub const fn new, Impl: IInkCursors_Impl, const OFFSET: isize>() -> IInkCursors_Vtbl { unsafe extern "system" fn Count, Impl: IInkCursors_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -949,19 +949,19 @@ impl IInkCursors_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkCustomStrokes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Item(&self, identifier: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Item(&self, identifier: &::windows_core::VARIANT) -> ::windows_core::Result; fn Add(&self, name: &::windows_core::BSTR, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result<()>; - fn Remove(&self, identifier: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Remove(&self, identifier: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkCustomStrokes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkCustomStrokes_Vtbl { pub const fn new, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>() -> IInkCustomStrokes_Vtbl { unsafe extern "system" fn Count, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -986,7 +986,7 @@ impl IInkCustomStrokes_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&identifier)) { @@ -1002,7 +1002,7 @@ impl IInkCustomStrokes_Vtbl { let this = (*this).get_impl(); this.Add(::core::mem::transmute(&name), ::windows_core::from_raw_borrowed(&strokes)).into() } - unsafe extern "system" fn Remove, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IInkCustomStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&identifier)).into() @@ -1026,8 +1026,8 @@ impl IInkCustomStrokes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDisp_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Strokes(&self) -> ::windows_core::Result; fn ExtendedProperties(&self) -> ::windows_core::Result; @@ -1043,21 +1043,21 @@ pub trait IInkDisp_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Clone(&self) -> ::windows_core::Result; fn HitTestCircle(&self, x: i32, y: i32, radius: f32) -> ::windows_core::Result; fn HitTestWithRectangle(&self, selectionrectangle: ::core::option::Option<&IInkRectangle>, intersectpercent: f32) -> ::windows_core::Result; - fn HitTestWithLasso(&self, points: &super::super::System::Variant::VARIANT, intersectpercent: f32, lassopoints: *mut super::super::System::Variant::VARIANT, strokes: *mut ::core::option::Option) -> ::windows_core::Result<()>; + fn HitTestWithLasso(&self, points: &::windows_core::VARIANT, intersectpercent: f32, lassopoints: *mut ::windows_core::VARIANT, strokes: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn NearestPoint(&self, x: i32, y: i32, pointonstroke: *mut f32, distancefrompacket: *mut f32, stroke: *mut ::core::option::Option) -> ::windows_core::Result<()>; - fn CreateStrokes(&self, strokeids: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn CreateStrokes(&self, strokeids: &::windows_core::VARIANT) -> ::windows_core::Result; fn AddStrokesAtRectangle(&self, sourcestrokes: ::core::option::Option<&IInkStrokes>, targetrectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<()>; - fn Save(&self, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode) -> ::windows_core::Result; - fn Load(&self, data: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn CreateStroke(&self, packetdata: &super::super::System::Variant::VARIANT, packetdescription: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; + fn Save(&self, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Load(&self, data: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn CreateStroke(&self, packetdata: &::windows_core::VARIANT, packetdescription: &::windows_core::VARIANT) -> ::windows_core::Result; fn ClipboardCopyWithRectangle(&self, rectangle: ::core::option::Option<&IInkRectangle>, clipboardformats: InkClipboardFormats, clipboardmodes: InkClipboardModes) -> ::windows_core::Result; fn ClipboardCopy(&self, strokes: ::core::option::Option<&IInkStrokes>, clipboardformats: InkClipboardFormats, clipboardmodes: InkClipboardModes) -> ::windows_core::Result; fn CanPaste(&self, dataobject: ::core::option::Option<&super::super::System::Com::IDataObject>) -> ::windows_core::Result; fn ClipboardPaste(&self, x: i32, y: i32, dataobject: ::core::option::Option<&super::super::System::Com::IDataObject>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDisp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDisp_Vtbl { pub const fn new, Impl: IInkDisp_Impl, const OFFSET: isize>() -> IInkDisp_Vtbl { unsafe extern "system" fn Strokes, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1190,7 +1190,7 @@ impl IInkDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn HitTestWithLasso, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: super::super::System::Variant::VARIANT, intersectpercent: f32, lassopoints: *mut super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn HitTestWithLasso, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: ::std::mem::MaybeUninit<::windows_core::VARIANT>, intersectpercent: f32, lassopoints: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.HitTestWithLasso(::core::mem::transmute(&points), ::core::mem::transmute_copy(&intersectpercent), ::core::mem::transmute_copy(&lassopoints), ::core::mem::transmute_copy(&strokes)).into() @@ -1200,7 +1200,7 @@ impl IInkDisp_Vtbl { let this = (*this).get_impl(); this.NearestPoint(::core::mem::transmute_copy(&x), ::core::mem::transmute_copy(&y), ::core::mem::transmute_copy(&pointonstroke), ::core::mem::transmute_copy(&distancefrompacket), ::core::mem::transmute_copy(&stroke)).into() } - unsafe extern "system" fn CreateStrokes, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokeids: super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateStrokes, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokeids: ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateStrokes(::core::mem::transmute(&strokeids)) { @@ -1216,7 +1216,7 @@ impl IInkDisp_Vtbl { let this = (*this).get_impl(); this.AddStrokesAtRectangle(::windows_core::from_raw_borrowed(&sourcestrokes), ::windows_core::from_raw_borrowed(&targetrectangle)).into() } - unsafe extern "system" fn Save, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode, data: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Save, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode, data: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Save(::core::mem::transmute_copy(&persistenceformat), ::core::mem::transmute_copy(&compressionmode)) { @@ -1227,12 +1227,12 @@ impl IInkDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Load, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Load, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Load(::core::mem::transmute(&data)).into() } - unsafe extern "system" fn CreateStroke, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetdata: super::super::System::Variant::VARIANT, packetdescription: super::super::System::Variant::VARIANT, stroke: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn CreateStroke, Impl: IInkDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, packetdescription: ::std::mem::MaybeUninit<::windows_core::VARIANT>, stroke: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.CreateStroke(::core::mem::transmute(&packetdata), ::core::mem::transmute(&packetdescription)) { @@ -1320,8 +1320,8 @@ impl IInkDisp_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDivider_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Strokes(&self) -> ::windows_core::Result; fn putref_Strokes(&self, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result<()>; @@ -1331,9 +1331,9 @@ pub trait IInkDivider_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetLineHeight(&self, lineheight: i32) -> ::windows_core::Result<()>; fn Divide(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDivider {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDivider_Vtbl { pub const fn new, Impl: IInkDivider_Impl, const OFFSET: isize>() -> IInkDivider_Vtbl { unsafe extern "system" fn Strokes, Impl: IInkDivider_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1410,15 +1410,15 @@ impl IInkDivider_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDivisionResult_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Strokes(&self) -> ::windows_core::Result; fn ResultByType(&self, divisiontype: InkDivisionType) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDivisionResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDivisionResult_Vtbl { pub const fn new, Impl: IInkDivisionResult_Impl, const OFFSET: isize>() -> IInkDivisionResult_Vtbl { unsafe extern "system" fn Strokes, Impl: IInkDivisionResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1453,17 +1453,17 @@ impl IInkDivisionResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDivisionUnit_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Strokes(&self) -> ::windows_core::Result; fn DivisionType(&self) -> ::windows_core::Result; fn RecognizedString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn RotationTransform(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDivisionUnit {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDivisionUnit_Vtbl { pub const fn new, Impl: IInkDivisionUnit_Impl, const OFFSET: isize>() -> IInkDivisionUnit_Vtbl { unsafe extern "system" fn Strokes, Impl: IInkDivisionUnit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1522,16 +1522,16 @@ impl IInkDivisionUnit_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDivisionUnits_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Item(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDivisionUnits {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDivisionUnits_Vtbl { pub const fn new, Impl: IInkDivisionUnits_Impl, const OFFSET: isize>() -> IInkDivisionUnits_Vtbl { unsafe extern "system" fn Count, Impl: IInkDivisionUnits_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -1578,8 +1578,8 @@ impl IInkDivisionUnits_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkDrawingAttributes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Color(&self) -> ::windows_core::Result; fn SetColor(&self, newcolor: i32) -> ::windows_core::Result<()>; @@ -1602,9 +1602,9 @@ pub trait IInkDrawingAttributes_Impl: Sized + super::super::System::Com::IDispat fn ExtendedProperties(&self) -> ::windows_core::Result; fn Clone(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkDrawingAttributes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkDrawingAttributes_Vtbl { pub const fn new, Impl: IInkDrawingAttributes_Impl, const OFFSET: isize>() -> IInkDrawingAttributes_Vtbl { unsafe extern "system" fn Color, Impl: IInkDrawingAttributes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentcolor: *mut i32) -> ::windows_core::HRESULT { @@ -1801,8 +1801,8 @@ impl IInkDrawingAttributes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IInkEdit_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Status(&self) -> ::windows_core::Result; fn UseMouseForInput(&self) -> ::windows_core::Result; @@ -1819,8 +1819,8 @@ pub trait IInkEdit_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn putref_Recognizer(&self, newval: ::core::option::Option<&IInkRecognizer>) -> ::windows_core::Result<()>; fn Factoid(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetFactoid(&self, newval: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn SelInks(&self) -> ::windows_core::Result; - fn SetSelInks(&self, selink: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SelInks(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelInks(&self, selink: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn SelInksDisplayMode(&self) -> ::windows_core::Result; fn SetSelInksDisplayMode(&self, inkdisplaymode: InkDisplayMode) -> ::windows_core::Result<()>; fn Recognize(&self) -> ::windows_core::Result<()>; @@ -1854,22 +1854,22 @@ pub trait IInkEdit_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetScrollBars(&self, newval: ScrollBarsConstants) -> ::windows_core::Result<()>; fn DisableNoScroll(&self) -> ::windows_core::Result; fn SetDisableNoScroll(&self, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn SelAlignment(&self) -> ::windows_core::Result; - fn SetSelAlignment(&self, pvarselalignment: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelBold(&self) -> ::windows_core::Result; - fn SetSelBold(&self, pvarselbold: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelItalic(&self) -> ::windows_core::Result; - fn SetSelItalic(&self, pvarselitalic: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelUnderline(&self) -> ::windows_core::Result; - fn SetSelUnderline(&self, pvarselunderline: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelColor(&self) -> ::windows_core::Result; - fn SetSelColor(&self, pvarselcolor: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelFontName(&self) -> ::windows_core::Result; - fn SetSelFontName(&self, pvarselfontname: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelFontSize(&self) -> ::windows_core::Result; - fn SetSelFontSize(&self, pvarselfontsize: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn SelCharOffset(&self) -> ::windows_core::Result; - fn SetSelCharOffset(&self, pvarselcharoffset: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SelAlignment(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelAlignment(&self, pvarselalignment: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelBold(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelBold(&self, pvarselbold: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelItalic(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelItalic(&self, pvarselitalic: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelUnderline(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelUnderline(&self, pvarselunderline: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelColor(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelColor(&self, pvarselcolor: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelFontName(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelFontName(&self, pvarselfontname: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelFontSize(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelFontSize(&self, pvarselfontsize: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn SelCharOffset(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetSelCharOffset(&self, pvarselcharoffset: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn TextRTF(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn SetTextRTF(&self, pbstrtextrtf: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn SelStart(&self) -> ::windows_core::Result; @@ -1882,9 +1882,9 @@ pub trait IInkEdit_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetSelRTF(&self, pbstrselrtf: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Refresh(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IInkEdit {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IInkEdit_Vtbl { pub const fn new, Impl: IInkEdit_Impl, const OFFSET: isize>() -> IInkEdit_Vtbl { unsafe extern "system" fn Status, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pstatus: *mut InkEditStatus) -> ::windows_core::HRESULT { @@ -2010,7 +2010,7 @@ impl IInkEdit_Vtbl { let this = (*this).get_impl(); this.SetFactoid(::core::mem::transmute(&newval)).into() } - unsafe extern "system" fn SelInks, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pselink: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelInks, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pselink: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelInks() { @@ -2021,7 +2021,7 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelInks, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, selink: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelInks, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, selink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelInks(::core::mem::transmute(&selink)).into() @@ -2287,7 +2287,7 @@ impl IInkEdit_Vtbl { let this = (*this).get_impl(); this.SetDisableNoScroll(::core::mem::transmute_copy(&newval)).into() } - unsafe extern "system" fn SelAlignment, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselalignment: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelAlignment, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselalignment: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelAlignment() { @@ -2298,12 +2298,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelAlignment, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselalignment: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelAlignment, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselalignment: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelAlignment(::core::mem::transmute(&pvarselalignment)).into() } - unsafe extern "system" fn SelBold, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselbold: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelBold, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselbold: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelBold() { @@ -2314,12 +2314,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelBold, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselbold: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelBold, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselbold: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelBold(::core::mem::transmute(&pvarselbold)).into() } - unsafe extern "system" fn SelItalic, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselitalic: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelItalic, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselitalic: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelItalic() { @@ -2330,12 +2330,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelItalic, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselitalic: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelItalic, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselitalic: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelItalic(::core::mem::transmute(&pvarselitalic)).into() } - unsafe extern "system" fn SelUnderline, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselunderline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelUnderline, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselunderline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelUnderline() { @@ -2346,12 +2346,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelUnderline, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselunderline: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelUnderline, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselunderline: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelUnderline(::core::mem::transmute(&pvarselunderline)).into() } - unsafe extern "system" fn SelColor, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcolor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelColor, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcolor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelColor() { @@ -2362,12 +2362,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelColor, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcolor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelColor, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcolor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelColor(::core::mem::transmute(&pvarselcolor)).into() } - unsafe extern "system" fn SelFontName, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontname: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelFontName, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontname: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelFontName() { @@ -2378,12 +2378,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelFontName, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontname: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelFontName, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontname: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelFontName(::core::mem::transmute(&pvarselfontname)).into() } - unsafe extern "system" fn SelFontSize, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontsize: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelFontSize, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontsize: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelFontSize() { @@ -2394,12 +2394,12 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelFontSize, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontsize: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelFontSize, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselfontsize: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelFontSize(::core::mem::transmute(&pvarselfontsize)).into() } - unsafe extern "system" fn SelCharOffset, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcharoffset: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelCharOffset, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcharoffset: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelCharOffset() { @@ -2410,7 +2410,7 @@ impl IInkEdit_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetSelCharOffset, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcharoffset: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetSelCharOffset, Impl: IInkEdit_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarselcharoffset: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetSelCharOffset(::core::mem::transmute(&pvarselcharoffset)).into() @@ -2585,20 +2585,20 @@ impl IInkEdit_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkExtendedProperties_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; - fn Item(&self, identifier: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Add(&self, guid: &::windows_core::BSTR, data: &super::super::System::Variant::VARIANT) -> ::windows_core::Result; - fn Remove(&self, identifier: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Item(&self, identifier: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Add(&self, guid: &::windows_core::BSTR, data: &::windows_core::VARIANT) -> ::windows_core::Result; + fn Remove(&self, identifier: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self) -> ::windows_core::Result<()>; fn DoesPropertyExist(&self, guid: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkExtendedProperties {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkExtendedProperties_Vtbl { pub const fn new, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>() -> IInkExtendedProperties_Vtbl { unsafe extern "system" fn Count, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -2623,7 +2623,7 @@ impl IInkExtendedProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Item, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, item: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Item, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, item: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Item(::core::mem::transmute(&identifier)) { @@ -2634,7 +2634,7 @@ impl IInkExtendedProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Add, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>, data: super::super::System::Variant::VARIANT, inkextendedproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { + unsafe extern "system" fn Add, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>, inkextendedproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Add(::core::mem::transmute(&guid), ::core::mem::transmute(&data)) { @@ -2645,7 +2645,7 @@ impl IInkExtendedProperties_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Remove, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Remove, Impl: IInkExtendedProperties_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.Remove(::core::mem::transmute(&identifier)).into() @@ -2681,16 +2681,16 @@ impl IInkExtendedProperties_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkExtendedProperty_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Guid(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn Data(&self) -> ::windows_core::Result; - fn SetData(&self, data: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn Data(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetData(&self, data: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkExtendedProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkExtendedProperty_Vtbl { pub const fn new, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>() -> IInkExtendedProperty_Vtbl { unsafe extern "system" fn Guid, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, guid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -2704,7 +2704,7 @@ impl IInkExtendedProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Data, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Data, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Data() { @@ -2715,7 +2715,7 @@ impl IInkExtendedProperty_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetData, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetData, Impl: IInkExtendedProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetData(::core::mem::transmute(&data)).into() @@ -2731,16 +2731,16 @@ impl IInkExtendedProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkGesture_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Confidence(&self) -> ::windows_core::Result; fn Id(&self) -> ::windows_core::Result; fn GetHotPoint(&self, x: *mut i32, y: *mut i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkGesture {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkGesture_Vtbl { pub const fn new, Impl: IInkGesture_Impl, const OFFSET: isize>() -> IInkGesture_Vtbl { unsafe extern "system" fn Confidence, Impl: IInkGesture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, confidence: *mut InkRecognitionConfidence) -> ::windows_core::HRESULT { @@ -2836,8 +2836,8 @@ impl IInkLineInfo_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IInkOverlay_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn hWnd(&self) -> ::windows_core::Result; fn SethWnd(&self, newwindow: isize) -> ::windows_core::Result<()>; @@ -2856,8 +2856,8 @@ pub trait IInkOverlay_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetCollectionMode(&self, mode: InkCollectionMode) -> ::windows_core::Result<()>; fn DynamicRendering(&self) -> ::windows_core::Result; fn SetDynamicRendering(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn DesiredPacketDescription(&self) -> ::windows_core::Result; - fn SetDesiredPacketDescription(&self, packetguids: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDesiredPacketDescription(&self, packetguids: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MouseIcon(&self) -> ::windows_core::Result; fn SetMouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; fn putref_MouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; @@ -2894,9 +2894,9 @@ pub trait IInkOverlay_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetEventInterest(&self, eventid: InkCollectorEventInterest) -> ::windows_core::Result; fn SetEventInterest(&self, eventid: InkCollectorEventInterest, listen: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IInkOverlay {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IInkOverlay_Vtbl { pub const fn new, Impl: IInkOverlay_Impl, const OFFSET: isize>() -> IInkOverlay_Vtbl { unsafe extern "system" fn hWnd, Impl: IInkOverlay_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentwindow: *mut isize) -> ::windows_core::HRESULT { @@ -3038,7 +3038,7 @@ impl IInkOverlay_Vtbl { let this = (*this).get_impl(); this.SetDynamicRendering(::core::mem::transmute_copy(&enabled)).into() } - unsafe extern "system" fn DesiredPacketDescription, Impl: IInkOverlay_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DesiredPacketDescription, Impl: IInkOverlay_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DesiredPacketDescription() { @@ -3049,7 +3049,7 @@ impl IInkOverlay_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkOverlay_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkOverlay_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDesiredPacketDescription(::core::mem::transmute(&packetguids)).into() @@ -3387,8 +3387,8 @@ impl IInkOverlay_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IInkPicture_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn hWnd(&self) -> ::windows_core::Result; fn DefaultDrawingAttributes(&self) -> ::windows_core::Result; @@ -3404,8 +3404,8 @@ pub trait IInkPicture_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetCollectionMode(&self, mode: InkCollectionMode) -> ::windows_core::Result<()>; fn DynamicRendering(&self) -> ::windows_core::Result; fn SetDynamicRendering(&self, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; - fn DesiredPacketDescription(&self) -> ::windows_core::Result; - fn SetDesiredPacketDescription(&self, packetguids: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetDesiredPacketDescription(&self, packetguids: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn MouseIcon(&self) -> ::windows_core::Result; fn SetMouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; fn putref_MouseIcon(&self, mouseicon: ::core::option::Option<&super::super::System::Ole::IPictureDisp>) -> ::windows_core::Result<()>; @@ -3450,9 +3450,9 @@ pub trait IInkPicture_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Enabled(&self) -> ::windows_core::Result; fn SetEnabled(&self, vbool: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IInkPicture {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IInkPicture_Vtbl { pub const fn new, Impl: IInkPicture_Impl, const OFFSET: isize>() -> IInkPicture_Vtbl { unsafe extern "system" fn hWnd, Impl: IInkPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, currentwindow: *mut isize) -> ::windows_core::HRESULT { @@ -3573,7 +3573,7 @@ impl IInkPicture_Vtbl { let this = (*this).get_impl(); this.SetDynamicRendering(::core::mem::transmute_copy(&enabled)).into() } - unsafe extern "system" fn DesiredPacketDescription, Impl: IInkPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn DesiredPacketDescription, Impl: IInkPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.DesiredPacketDescription() { @@ -3584,7 +3584,7 @@ impl IInkPicture_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetDesiredPacketDescription, Impl: IInkPicture_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetDesiredPacketDescription(::core::mem::transmute(&packetguids)).into() @@ -3991,15 +3991,15 @@ impl IInkPicture_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognitionAlternate_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn String(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Confidence(&self) -> ::windows_core::Result; - fn Baseline(&self) -> ::windows_core::Result; - fn Midline(&self) -> ::windows_core::Result; - fn Ascender(&self) -> ::windows_core::Result; - fn Descender(&self) -> ::windows_core::Result; + fn Baseline(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Midline(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Ascender(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn Descender(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn LineNumber(&self) -> ::windows_core::Result; fn Strokes(&self) -> ::windows_core::Result; fn LineAlternates(&self) -> ::windows_core::Result; @@ -4008,11 +4008,11 @@ pub trait IInkRecognitionAlternate_Impl: Sized + super::super::System::Com::IDis fn GetStrokesFromTextRange(&self, selectionstart: *mut i32, selectionlength: *mut i32, getstrokesfromtextrange: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn GetTextRangeFromStrokes(&self, strokes: ::core::option::Option<&IInkStrokes>, selectionstart: *mut i32, selectionlength: *mut i32) -> ::windows_core::Result<()>; fn AlternatesWithConstantPropertyValues(&self, propertytype: &::windows_core::BSTR) -> ::windows_core::Result; - fn GetPropertyValue(&self, propertytype: &::windows_core::BSTR) -> ::windows_core::Result; + fn GetPropertyValue(&self, propertytype: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognitionAlternate {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognitionAlternate_Vtbl { pub const fn new, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>() -> IInkRecognitionAlternate_Vtbl { unsafe extern "system" fn String, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, recostring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4037,7 +4037,7 @@ impl IInkRecognitionAlternate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Baseline, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, baseline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Baseline, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, baseline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Baseline() { @@ -4048,7 +4048,7 @@ impl IInkRecognitionAlternate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Midline, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, midline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Midline, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, midline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Midline() { @@ -4059,7 +4059,7 @@ impl IInkRecognitionAlternate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Ascender, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ascender: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Ascender, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ascender: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Ascender() { @@ -4070,7 +4070,7 @@ impl IInkRecognitionAlternate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Descender, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, descender: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Descender, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, descender: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Descender() { @@ -4157,7 +4157,7 @@ impl IInkRecognitionAlternate_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPropertyValue, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertytype: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPropertyValue, Impl: IInkRecognitionAlternate_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertytype: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPropertyValue(::core::mem::transmute(&propertytype)) { @@ -4191,17 +4191,17 @@ impl IInkRecognitionAlternate_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognitionAlternates_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn Strokes(&self) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognitionAlternates {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognitionAlternates_Vtbl { pub const fn new, Impl: IInkRecognitionAlternates_Impl, const OFFSET: isize>() -> IInkRecognitionAlternates_Vtbl { unsafe extern "system" fn Count, Impl: IInkRecognitionAlternates_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4260,8 +4260,8 @@ impl IInkRecognitionAlternates_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognitionResult_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn TopString(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn TopAlternate(&self) -> ::windows_core::Result; @@ -4271,9 +4271,9 @@ pub trait IInkRecognitionResult_Impl: Sized + super::super::System::Com::IDispat fn ModifyTopAlternate(&self, alternate: ::core::option::Option<&IInkRecognitionAlternate>) -> ::windows_core::Result<()>; fn SetResultOnStrokes(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognitionResult {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognitionResult_Vtbl { pub const fn new, Impl: IInkRecognitionResult_Impl, const OFFSET: isize>() -> IInkRecognitionResult_Vtbl { unsafe extern "system" fn TopString, Impl: IInkRecognitionResult_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, topstring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4356,20 +4356,20 @@ impl IInkRecognitionResult_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Vendor(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn Capabilities(&self) -> ::windows_core::Result; - fn Languages(&self) -> ::windows_core::Result; - fn SupportedProperties(&self) -> ::windows_core::Result; - fn PreferredPacketDescription(&self) -> ::windows_core::Result; + fn Languages(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SupportedProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn PreferredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn CreateRecognizerContext(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizer_Vtbl { pub const fn new, Impl: IInkRecognizer_Impl, const OFFSET: isize>() -> IInkRecognizer_Vtbl { unsafe extern "system" fn Name, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4405,7 +4405,7 @@ impl IInkRecognizer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn Languages, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, languages: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn Languages, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, languages: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Languages() { @@ -4416,7 +4416,7 @@ impl IInkRecognizer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SupportedProperties, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, supportedproperties: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SupportedProperties, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, supportedproperties: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SupportedProperties() { @@ -4427,7 +4427,7 @@ impl IInkRecognizer_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PreferredPacketDescription, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, preferredpacketdescription: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PreferredPacketDescription, Impl: IInkRecognizer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, preferredpacketdescription: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PreferredPacketDescription() { @@ -4464,15 +4464,15 @@ impl IInkRecognizer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizer2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Id(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn UnicodeRanges(&self) -> ::windows_core::Result; + fn UnicodeRanges(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizer2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizer2_Vtbl { pub const fn new, Impl: IInkRecognizer2_Impl, const OFFSET: isize>() -> IInkRecognizer2_Vtbl { unsafe extern "system" fn Id, Impl: IInkRecognizer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pbstrid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -4486,7 +4486,7 @@ impl IInkRecognizer2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn UnicodeRanges, Impl: IInkRecognizer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn UnicodeRanges, Impl: IInkRecognizer2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.UnicodeRanges() { @@ -4507,8 +4507,8 @@ impl IInkRecognizer2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizerContext_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Strokes(&self) -> ::windows_core::Result; fn putref_Strokes(&self, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result<()>; @@ -4530,14 +4530,14 @@ pub trait IInkRecognizerContext_Impl: Sized + super::super::System::Com::IDispat fn Recognize(&self, recognitionstatus: *mut InkRecognitionStatus, recognitionresult: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn StopBackgroundRecognition(&self) -> ::windows_core::Result<()>; fn EndInkInput(&self) -> ::windows_core::Result<()>; - fn BackgroundRecognize(&self, customdata: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn BackgroundRecognizeWithAlternates(&self, customdata: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn BackgroundRecognize(&self, customdata: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn BackgroundRecognizeWithAlternates(&self, customdata: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clone(&self) -> ::windows_core::Result; fn IsStringSupported(&self, string: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizerContext {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizerContext_Vtbl { pub const fn new, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>() -> IInkRecognizerContext_Vtbl { unsafe extern "system" fn Strokes, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4694,12 +4694,12 @@ impl IInkRecognizerContext_Vtbl { let this = (*this).get_impl(); this.EndInkInput().into() } - unsafe extern "system" fn BackgroundRecognize, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BackgroundRecognize, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, customdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.BackgroundRecognize(::core::mem::transmute(&customdata)).into() } - unsafe extern "system" fn BackgroundRecognizeWithAlternates, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BackgroundRecognizeWithAlternates, Impl: IInkRecognizerContext_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, customdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.BackgroundRecognizeWithAlternates(::core::mem::transmute(&customdata)).into() @@ -4758,18 +4758,18 @@ impl IInkRecognizerContext_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizerContext2_Impl: Sized + super::super::System::Com::IDispatch_Impl { - fn EnabledUnicodeRanges(&self) -> ::windows_core::Result; - fn SetEnabledUnicodeRanges(&self, unicoderanges: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn EnabledUnicodeRanges(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetEnabledUnicodeRanges(&self, unicoderanges: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizerContext2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizerContext2_Vtbl { pub const fn new, Impl: IInkRecognizerContext2_Impl, const OFFSET: isize>() -> IInkRecognizerContext2_Vtbl { - unsafe extern "system" fn EnabledUnicodeRanges, Impl: IInkRecognizerContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn EnabledUnicodeRanges, Impl: IInkRecognizerContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.EnabledUnicodeRanges() { @@ -4780,7 +4780,7 @@ impl IInkRecognizerContext2_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetEnabledUnicodeRanges, Impl: IInkRecognizerContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetEnabledUnicodeRanges, Impl: IInkRecognizerContext2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, unicoderanges: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetEnabledUnicodeRanges(::core::mem::transmute(&unicoderanges)).into() @@ -4795,8 +4795,8 @@ impl IInkRecognizerContext2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizerGuide_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn WritingBox(&self) -> ::windows_core::Result; fn SetWritingBox(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<()>; @@ -4811,9 +4811,9 @@ pub trait IInkRecognizerGuide_Impl: Sized + super::super::System::Com::IDispatch fn GuideData(&self, precoguide: *mut InkRecoGuide) -> ::windows_core::Result<()>; fn SetGuideData(&self, recoguide: &InkRecoGuide) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizerGuide {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizerGuide_Vtbl { pub const fn new, Impl: IInkRecognizerGuide_Impl, const OFFSET: isize>() -> IInkRecognizerGuide_Vtbl { unsafe extern "system" fn WritingBox, Impl: IInkRecognizerGuide_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rectangle: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -4926,17 +4926,17 @@ impl IInkRecognizerGuide_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRecognizers_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; fn GetDefaultRecognizer(&self, lcid: i32) -> ::windows_core::Result; fn Item(&self, index: i32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRecognizers {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRecognizers_Vtbl { pub const fn new, Impl: IInkRecognizers_Impl, const OFFSET: isize>() -> IInkRecognizers_Vtbl { unsafe extern "system" fn Count, Impl: IInkRecognizers_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -4995,8 +4995,8 @@ impl IInkRecognizers_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRectangle_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Top(&self) -> ::windows_core::Result; fn SetTop(&self, units: i32) -> ::windows_core::Result<()>; @@ -5011,9 +5011,9 @@ pub trait IInkRectangle_Impl: Sized + super::super::System::Com::IDispatch_Impl fn GetRectangle(&self, top: *mut i32, left: *mut i32, bottom: *mut i32, right: *mut i32) -> ::windows_core::Result<()>; fn SetRectangle(&self, top: i32, left: i32, bottom: i32, right: i32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRectangle {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRectangle_Vtbl { pub const fn new, Impl: IInkRectangle_Impl, const OFFSET: isize>() -> IInkRectangle_Vtbl { unsafe extern "system" fn Top, Impl: IInkRectangle_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, units: *mut i32) -> ::windows_core::HRESULT { @@ -5126,8 +5126,8 @@ impl IInkRectangle_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkRenderer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn GetViewTransform(&self, viewtransform: ::core::option::Option<&IInkTransform>) -> ::windows_core::Result<()>; fn SetViewTransform(&self, viewtransform: ::core::option::Option<&IInkTransform>) -> ::windows_core::Result<()>; @@ -5137,17 +5137,17 @@ pub trait IInkRenderer_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DrawStroke(&self, hdc: isize, stroke: ::core::option::Option<&IInkStrokeDisp>, drawingattributes: ::core::option::Option<&IInkDrawingAttributes>) -> ::windows_core::Result<()>; fn PixelToInkSpace(&self, hdc: isize, x: *mut i32, y: *mut i32) -> ::windows_core::Result<()>; fn InkSpaceToPixel(&self, hdcdisplay: isize, x: *mut i32, y: *mut i32) -> ::windows_core::Result<()>; - fn PixelToInkSpaceFromPoints(&self, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn InkSpaceToPixelFromPoints(&self, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn PixelToInkSpaceFromPoints(&self, hdc: isize, points: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn InkSpaceToPixelFromPoints(&self, hdc: isize, points: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Measure(&self, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result; fn MeasureStroke(&self, stroke: ::core::option::Option<&IInkStrokeDisp>, drawingattributes: ::core::option::Option<&IInkDrawingAttributes>) -> ::windows_core::Result; fn Move(&self, horizontalcomponent: f32, verticalcomponent: f32) -> ::windows_core::Result<()>; fn Rotate(&self, degrees: f32, x: f32, y: f32) -> ::windows_core::Result<()>; fn ScaleTransform(&self, horizontalmultiplier: f32, verticalmultiplier: f32, applyonpenwidth: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkRenderer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkRenderer_Vtbl { pub const fn new, Impl: IInkRenderer_Impl, const OFFSET: isize>() -> IInkRenderer_Vtbl { unsafe extern "system" fn GetViewTransform, Impl: IInkRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, viewtransform: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -5190,12 +5190,12 @@ impl IInkRenderer_Vtbl { let this = (*this).get_impl(); this.InkSpaceToPixel(::core::mem::transmute_copy(&hdcdisplay), ::core::mem::transmute_copy(&x), ::core::mem::transmute_copy(&y)).into() } - unsafe extern "system" fn PixelToInkSpaceFromPoints, Impl: IInkRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PixelToInkSpaceFromPoints, Impl: IInkRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.PixelToInkSpaceFromPoints(::core::mem::transmute_copy(&hdc), ::core::mem::transmute_copy(&points)).into() } - unsafe extern "system" fn InkSpaceToPixelFromPoints, Impl: IInkRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn InkSpaceToPixelFromPoints, Impl: IInkRenderer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.InkSpaceToPixelFromPoints(::core::mem::transmute_copy(&hdc), ::core::mem::transmute_copy(&points)).into() @@ -5260,36 +5260,36 @@ impl IInkRenderer_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkStrokeDisp_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ID(&self) -> ::windows_core::Result; - fn BezierPoints(&self) -> ::windows_core::Result; + fn BezierPoints(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn DrawingAttributes(&self) -> ::windows_core::Result; fn putref_DrawingAttributes(&self, drawattrs: ::core::option::Option<&IInkDrawingAttributes>) -> ::windows_core::Result<()>; fn Ink(&self) -> ::windows_core::Result; fn ExtendedProperties(&self) -> ::windows_core::Result; - fn PolylineCusps(&self) -> ::windows_core::Result; - fn BezierCusps(&self) -> ::windows_core::Result; - fn SelfIntersections(&self) -> ::windows_core::Result; + fn PolylineCusps(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn BezierCusps(&self) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SelfIntersections(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn PacketCount(&self) -> ::windows_core::Result; fn PacketSize(&self) -> ::windows_core::Result; - fn PacketDescription(&self) -> ::windows_core::Result; + fn PacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn Deleted(&self) -> ::windows_core::Result; fn GetBoundingBox(&self, boundingboxmode: InkBoundingBoxMode) -> ::windows_core::Result; - fn FindIntersections(&self, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result; - fn GetRectangleIntersections(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result; + fn FindIntersections(&self, strokes: ::core::option::Option<&IInkStrokes>) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetRectangleIntersections(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<::windows_core::VARIANT>; fn Clip(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<()>; fn HitTestCircle(&self, x: i32, y: i32, radius: f32) -> ::windows_core::Result; fn NearestPoint(&self, x: i32, y: i32, distance: *mut f32, point: *mut f32) -> ::windows_core::Result<()>; fn Split(&self, splitat: f32) -> ::windows_core::Result; fn GetPacketDescriptionPropertyMetrics(&self, propertyname: &::windows_core::BSTR, minimum: *mut i32, maximum: *mut i32, units: *mut TabletPropertyMetricUnit, resolution: *mut f32) -> ::windows_core::Result<()>; - fn GetPoints(&self, index: i32, count: i32) -> ::windows_core::Result; - fn SetPoints(&self, points: &super::super::System::Variant::VARIANT, index: i32, count: i32) -> ::windows_core::Result; - fn GetPacketData(&self, index: i32, count: i32) -> ::windows_core::Result; - fn GetPacketValuesByProperty(&self, propertyname: &::windows_core::BSTR, index: i32, count: i32) -> ::windows_core::Result; - fn SetPacketValuesByProperty(&self, bstrpropertyname: &::windows_core::BSTR, packetvalues: &super::super::System::Variant::VARIANT, index: i32, count: i32) -> ::windows_core::Result; - fn GetFlattenedBezierPoints(&self, fittingerror: i32) -> ::windows_core::Result; + fn GetPoints(&self, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPoints(&self, points: &::windows_core::VARIANT, index: i32, count: i32) -> ::windows_core::Result; + fn GetPacketData(&self, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn GetPacketValuesByProperty(&self, propertyname: &::windows_core::BSTR, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT>; + fn SetPacketValuesByProperty(&self, bstrpropertyname: &::windows_core::BSTR, packetvalues: &::windows_core::VARIANT, index: i32, count: i32) -> ::windows_core::Result; + fn GetFlattenedBezierPoints(&self, fittingerror: i32) -> ::windows_core::Result<::windows_core::VARIANT>; fn Transform(&self, transform: ::core::option::Option<&IInkTransform>, applyonpenwidth: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn ScaleToRectangle(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<()>; fn Move(&self, horizontalcomponent: f32, verticalcomponent: f32) -> ::windows_core::Result<()>; @@ -5297,9 +5297,9 @@ pub trait IInkStrokeDisp_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Shear(&self, horizontalmultiplier: f32, verticalmultiplier: f32) -> ::windows_core::Result<()>; fn ScaleTransform(&self, horizontalmultiplier: f32, verticalmultiplier: f32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkStrokeDisp {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkStrokeDisp_Vtbl { pub const fn new, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>() -> IInkStrokeDisp_Vtbl { unsafe extern "system" fn ID, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT { @@ -5313,7 +5313,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BezierPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BezierPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BezierPoints() { @@ -5362,7 +5362,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PolylineCusps, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cusps: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PolylineCusps, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cusps: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PolylineCusps() { @@ -5373,7 +5373,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn BezierCusps, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cusps: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn BezierCusps, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, cusps: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.BezierCusps() { @@ -5384,7 +5384,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SelfIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SelfIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SelfIntersections() { @@ -5417,7 +5417,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn PacketDescription, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetdescription: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn PacketDescription, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, packetdescription: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.PacketDescription() { @@ -5450,7 +5450,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn FindIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn FindIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, strokes: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.FindIntersections(::windows_core::from_raw_borrowed(&strokes)) { @@ -5461,7 +5461,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetRectangleIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetRectangleIntersections, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetRectangleIntersections(::windows_core::from_raw_borrowed(&rectangle)) { @@ -5509,7 +5509,7 @@ impl IInkStrokeDisp_Vtbl { let this = (*this).get_impl(); this.GetPacketDescriptionPropertyMetrics(::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&minimum), ::core::mem::transmute_copy(&maximum), ::core::mem::transmute_copy(&units), ::core::mem::transmute_copy(&resolution)).into() } - unsafe extern "system" fn GetPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, count: i32, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, count: i32, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPoints(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&count)) { @@ -5520,7 +5520,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: super::super::System::Variant::VARIANT, index: i32, count: i32, numberofpointsset: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, points: ::std::mem::MaybeUninit<::windows_core::VARIANT>, index: i32, count: i32, numberofpointsset: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SetPoints(::core::mem::transmute(&points), ::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&count)) { @@ -5531,7 +5531,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPacketData, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, count: i32, packetdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPacketData, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, index: i32, count: i32, packetdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPacketData(::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&count)) { @@ -5542,7 +5542,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetPacketValuesByProperty, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, index: i32, count: i32, packetvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetPacketValuesByProperty, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, index: i32, count: i32, packetvalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetPacketValuesByProperty(::core::mem::transmute(&propertyname), ::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&count)) { @@ -5553,7 +5553,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetPacketValuesByProperty, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, packetvalues: super::super::System::Variant::VARIANT, index: i32, count: i32, numberofpacketsset: *mut i32) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetPacketValuesByProperty, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, packetvalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>, index: i32, count: i32, numberofpacketsset: *mut i32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.SetPacketValuesByProperty(::core::mem::transmute(&bstrpropertyname), ::core::mem::transmute(&packetvalues), ::core::mem::transmute_copy(&index), ::core::mem::transmute_copy(&count)) { @@ -5564,7 +5564,7 @@ impl IInkStrokeDisp_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetFlattenedBezierPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fittingerror: i32, flattenedbezierpoints: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetFlattenedBezierPoints, Impl: IInkStrokeDisp_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, fittingerror: i32, flattenedbezierpoints: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetFlattenedBezierPoints(::core::mem::transmute_copy(&fittingerror)) { @@ -5646,8 +5646,8 @@ impl IInkStrokeDisp_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkStrokes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -5670,9 +5670,9 @@ pub trait IInkStrokes_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Clip(&self, rectangle: ::core::option::Option<&IInkRectangle>) -> ::windows_core::Result<()>; fn RemoveRecognitionResult(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkStrokes {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkStrokes_Vtbl { pub const fn new, Impl: IInkStrokes_Impl, const OFFSET: isize>() -> IInkStrokes_Vtbl { unsafe extern "system" fn Count, Impl: IInkStrokes_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -5845,8 +5845,8 @@ impl IInkStrokes_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkTablet_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Name(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn PlugAndPlayId(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -5855,9 +5855,9 @@ pub trait IInkTablet_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsPacketPropertySupported(&self, packetpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; fn GetPropertyMetrics(&self, propertyname: &::windows_core::BSTR, minimum: *mut i32, maximum: *mut i32, units: *mut TabletPropertyMetricUnit, resolution: *mut f32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkTablet {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkTablet_Vtbl { pub const fn new, Impl: IInkTablet_Impl, const OFFSET: isize>() -> IInkTablet_Vtbl { unsafe extern "system" fn Name, Impl: IInkTablet_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -5934,14 +5934,14 @@ impl IInkTablet_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkTablet2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn DeviceKind(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkTablet2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkTablet2_Vtbl { pub const fn new, Impl: IInkTablet2_Impl, const OFFSET: isize>() -> IInkTablet2_Vtbl { unsafe extern "system" fn DeviceKind, Impl: IInkTablet2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, kind: *mut TabletDeviceKind) -> ::windows_core::HRESULT { @@ -5961,15 +5961,15 @@ impl IInkTablet2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkTablet3_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn IsMultiTouch(&self) -> ::windows_core::Result; fn MaximumCursors(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkTablet3 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkTablet3_Vtbl { pub const fn new, Impl: IInkTablet3_Impl, const OFFSET: isize>() -> IInkTablet3_Vtbl { unsafe extern "system" fn IsMultiTouch, Impl: IInkTablet3_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pismultitouch: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -6004,8 +6004,8 @@ impl IInkTablet3_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkTablets_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Count(&self) -> ::windows_core::Result; fn _NewEnum(&self) -> ::windows_core::Result<::windows_core::IUnknown>; @@ -6013,9 +6013,9 @@ pub trait IInkTablets_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Item(&self, index: i32) -> ::windows_core::Result; fn IsPacketPropertySupported(&self, packetpropertyname: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkTablets {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkTablets_Vtbl { pub const fn new, Impl: IInkTablets_Impl, const OFFSET: isize>() -> IInkTablets_Vtbl { unsafe extern "system" fn Count, Impl: IInkTablets_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT { @@ -6086,8 +6086,8 @@ impl IInkTablets_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_Graphics_Gdi\"`, `\"Win32_System_Com\"`"] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com"))] pub trait IInkTransform_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Reset(&self) -> ::windows_core::Result<()>; fn Translate(&self, horizontalcomponent: f32, verticalcomponent: f32) -> ::windows_core::Result<()>; @@ -6112,9 +6112,9 @@ pub trait IInkTransform_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Data(&self, xform: *mut super::super::Graphics::Gdi::XFORM) -> ::windows_core::Result<()>; fn SetData(&self, xform: &super::super::Graphics::Gdi::XFORM) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com"))] impl ::windows_core::RuntimeName for IInkTransform {} -#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_Graphics_Gdi", feature = "Win32_System_Com"))] impl IInkTransform_Vtbl { pub const fn new, Impl: IInkTransform_Impl, const OFFSET: isize>() -> IInkTransform_Vtbl { unsafe extern "system" fn Reset, Impl: IInkTransform_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6293,16 +6293,16 @@ impl IInkTransform_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkWordList_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AddWord(&self, newword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn RemoveWord(&self, removeword: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Merge(&self, mergewordlist: ::core::option::Option<&IInkWordList>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkWordList {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkWordList_Vtbl { pub const fn new, Impl: IInkWordList_Impl, const OFFSET: isize>() -> IInkWordList_Vtbl { unsafe extern "system" fn AddWord, Impl: IInkWordList_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newword: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6331,14 +6331,14 @@ impl IInkWordList_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IInkWordList2_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn AddWords(&self, newwords: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IInkWordList2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IInkWordList2_Vtbl { pub const fn new, Impl: IInkWordList2_Impl, const OFFSET: isize>() -> IInkWordList2_Vtbl { unsafe extern "system" fn AddWords, Impl: IInkWordList2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, newwords: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -6405,8 +6405,8 @@ impl IInputPanelWindowHandle_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub trait IMathInputControl_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Show(&self) -> ::windows_core::Result<()>; fn Hide(&self) -> ::windows_core::Result<()>; @@ -6426,9 +6426,9 @@ pub trait IMathInputControl_Impl: Sized + super::super::System::Com::IDispatch_I fn RemoveFunctionName(&self, functionname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn GetHoverIcon(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl ::windows_core::RuntimeName for IMathInputControl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] impl IMathInputControl_Vtbl { pub const fn new, Impl: IMathInputControl_Impl, const OFFSET: isize>() -> IMathInputControl_Vtbl { unsafe extern "system" fn Show, Impl: IMathInputControl_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -6559,8 +6559,8 @@ impl IMathInputControl_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IPenInputPanel_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn Busy(&self) -> ::windows_core::Result; fn Factoid(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -6588,9 +6588,9 @@ pub trait IPenInputPanel_Impl: Sized + super::super::System::Com::IDispatch_Impl fn Refresh(&self) -> ::windows_core::Result<()>; fn EnableTsf(&self, enable: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IPenInputPanel {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IPenInputPanel_Vtbl { pub const fn new, Impl: IPenInputPanel_Impl, const OFFSET: isize>() -> IPenInputPanel_Vtbl { unsafe extern "system" fn Busy, Impl: IPenInputPanel_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, busy: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -7234,12 +7234,12 @@ impl IRealTimeStylusSynchronization_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ISketchInk_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ISketchInk {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ISketchInk_Vtbl { pub const fn new, Impl: ISketchInk_Impl, const OFFSET: isize>() -> ISketchInk_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7954,12 +7954,12 @@ impl ITipAutoCompleteProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkCollectorEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkCollectorEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkCollectorEvents_Vtbl { pub const fn new, Impl: _IInkCollectorEvents_Impl, const OFFSET: isize>() -> _IInkCollectorEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7968,12 +7968,12 @@ impl _IInkCollectorEvents_Vtbl { iid == &<_IInkCollectorEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkEditEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkEditEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkEditEvents_Vtbl { pub const fn new, Impl: _IInkEditEvents_Impl, const OFFSET: isize>() -> _IInkEditEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7982,12 +7982,12 @@ impl _IInkEditEvents_Vtbl { iid == &<_IInkEditEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkEvents_Vtbl { pub const fn new, Impl: _IInkEvents_Impl, const OFFSET: isize>() -> _IInkEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -7996,12 +7996,12 @@ impl _IInkEvents_Vtbl { iid == &<_IInkEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkOverlayEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkOverlayEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkOverlayEvents_Vtbl { pub const fn new, Impl: _IInkOverlayEvents_Impl, const OFFSET: isize>() -> _IInkOverlayEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8010,12 +8010,12 @@ impl _IInkOverlayEvents_Vtbl { iid == &<_IInkOverlayEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkPictureEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkPictureEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkPictureEvents_Vtbl { pub const fn new, Impl: _IInkPictureEvents_Impl, const OFFSET: isize>() -> _IInkPictureEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8024,12 +8024,12 @@ impl _IInkPictureEvents_Vtbl { iid == &<_IInkPictureEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkRecognitionEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkRecognitionEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkRecognitionEvents_Vtbl { pub const fn new, Impl: _IInkRecognitionEvents_Impl, const OFFSET: isize>() -> _IInkRecognitionEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8038,12 +8038,12 @@ impl _IInkRecognitionEvents_Vtbl { iid == &<_IInkRecognitionEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IInkStrokesEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IInkStrokesEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IInkStrokesEvents_Vtbl { pub const fn new, Impl: _IInkStrokesEvents_Impl, const OFFSET: isize>() -> _IInkStrokesEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8052,12 +8052,12 @@ impl _IInkStrokesEvents_Vtbl { iid == &<_IInkStrokesEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IMathInputControlEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IMathInputControlEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IMathInputControlEvents_Vtbl { pub const fn new, Impl: _IMathInputControlEvents_Impl, const OFFSET: isize>() -> _IMathInputControlEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -8066,12 +8066,12 @@ impl _IMathInputControlEvents_Vtbl { iid == &<_IMathInputControlEvents as ::windows_core::Interface>::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait _IPenInputPanelEvents_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for _IPenInputPanelEvents {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl _IPenInputPanelEvents_Vtbl { pub const fn new, Impl: _IPenInputPanelEvents_Impl, const OFFSET: isize>() -> _IPenInputPanelEvents_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } diff --git a/crates/libs/windows/src/Windows/Win32/UI/TabletPC/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/TabletPC/mod.rs index 44b5196b29..d1575f374e 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/TabletPC/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/TabletPC/mod.rs @@ -506,16 +506,15 @@ impl IInkCollector { { (::windows_core::Interface::vtable(self).SetDynamicRendering)(::windows_core::Interface::as_raw(self), enabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result { + pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DesiredPacketDescription)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDesiredPacketDescription(&self, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(packetguids)).ok() + pub unsafe fn SetDesiredPacketDescription(&self, packetguids: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), packetguids.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] @@ -670,14 +669,8 @@ pub struct IInkCollector_Vtbl { pub SetCollectionMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mode: InkCollectionMode) -> ::windows_core::HRESULT, pub DynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetDynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DesiredPacketDescription: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDesiredPacketDescription: usize, + pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub MouseIcon: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mouseicon: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole")))] @@ -851,11 +844,14 @@ impl IInkCursorButtons { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, identifier: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(identifier), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), identifier.into_param().abi(), &mut result__).from_abi(result__) } } #[cfg(feature = "Win32_System_Com")] @@ -865,9 +861,9 @@ pub struct IInkCursorButtons_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, _newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, button: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, button: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, } #[cfg(feature = "Win32_System_Com")] @@ -927,11 +923,14 @@ impl IInkCustomStrokes { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, identifier: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(identifier), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), identifier.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -942,10 +941,11 @@ impl IInkCustomStrokes { { (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), name.into_param().abi(), strokes.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(identifier)).ok() + pub unsafe fn Remove(&self, identifier: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), identifier.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -958,18 +958,15 @@ pub struct IInkCustomStrokes_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, _newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, #[cfg(feature = "Win32_System_Com")] pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, strokes: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -1080,21 +1077,27 @@ impl IInkDisp { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).HitTestWithRectangle)(::windows_core::Interface::as_raw(self), selectionrectangle.into_param().abi(), intersectpercent, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn HitTestWithLasso(&self, points: super::super::System::Variant::VARIANT, intersectpercent: f32, lassopoints: ::core::option::Option<*mut super::super::System::Variant::VARIANT>, strokes: *mut ::core::option::Option) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).HitTestWithLasso)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(points), intersectpercent, ::core::mem::transmute(lassopoints.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(strokes)).ok() + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn HitTestWithLasso(&self, points: P0, intersectpercent: f32, lassopoints: ::core::option::Option<*mut ::windows_core::VARIANT>, strokes: *mut ::core::option::Option) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).HitTestWithLasso)(::windows_core::Interface::as_raw(self), points.into_param().abi(), intersectpercent, ::core::mem::transmute(lassopoints.unwrap_or(::std::ptr::null_mut())), ::core::mem::transmute(strokes)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] pub unsafe fn NearestPoint(&self, x: i32, y: i32, pointonstroke: *mut f32, distancefrompacket: *mut f32, stroke: *mut ::core::option::Option) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).NearestPoint)(::windows_core::Interface::as_raw(self), x, y, pointonstroke, distancefrompacket, ::core::mem::transmute(stroke)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateStrokes(&self, strokeids: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateStrokes(&self, strokeids: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateStrokes)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(strokeids), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateStrokes)(::windows_core::Interface::as_raw(self), strokeids.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1105,22 +1108,25 @@ impl IInkDisp { { (::windows_core::Interface::vtable(self).AddStrokesAtRectangle)(::windows_core::Interface::as_raw(self), sourcestrokes.into_param().abi(), targetrectangle.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Save(&self, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode) -> ::windows_core::Result { + pub unsafe fn Save(&self, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Save)(::windows_core::Interface::as_raw(self), persistenceformat, compressionmode, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Load(&self, data: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Load)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(data)).ok() + pub unsafe fn Load(&self, data: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Load)(::windows_core::Interface::as_raw(self), data.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CreateStroke(&self, packetdata: super::super::System::Variant::VARIANT, packetdescription: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn CreateStroke(&self, packetdata: P0, packetdescription: P1) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).CreateStroke)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(packetdata), ::core::mem::transmute(packetdescription), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).CreateStroke)(::windows_core::Interface::as_raw(self), packetdata.into_param().abi(), packetdescription.into_param().abi(), &mut result__).from_abi(result__) } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -1214,33 +1220,27 @@ pub struct IInkDisp_Vtbl { pub HitTestWithRectangle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, selectionrectangle: *mut ::core::ffi::c_void, intersectpercent: f32, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] HitTestWithRectangle: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub HitTestWithLasso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: super::super::System::Variant::VARIANT, intersectpercent: f32, lassopoints: *mut super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub HitTestWithLasso: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: ::std::mem::MaybeUninit<::windows_core::VARIANT>, intersectpercent: f32, lassopoints: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] HitTestWithLasso: usize, #[cfg(feature = "Win32_System_Com")] pub NearestPoint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, x: i32, y: i32, pointonstroke: *mut f32, distancefrompacket: *mut f32, stroke: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] NearestPoint: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateStrokes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokeids: super::super::System::Variant::VARIANT, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub CreateStrokes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokeids: ::std::mem::MaybeUninit<::windows_core::VARIANT>, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateStrokes: usize, #[cfg(feature = "Win32_System_Com")] pub AddStrokesAtRectangle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, sourcestrokes: *mut ::core::ffi::c_void, targetrectangle: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AddStrokesAtRectangle: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode, data: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Save: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Load: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CreateStroke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetdata: super::super::System::Variant::VARIANT, packetdescription: super::super::System::Variant::VARIANT, stroke: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + pub Save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, persistenceformat: InkPersistenceFormat, compressionmode: InkPersistenceCompressionMode, data: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(feature = "Win32_System_Com")] + pub CreateStroke: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>, packetdescription: ::std::mem::MaybeUninit<::windows_core::VARIANT>, stroke: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] CreateStroke: usize, #[cfg(feature = "Win32_System_Com")] pub ClipboardCopyWithRectangle: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void, clipboardformats: InkClipboardFormats, clipboardmodes: InkClipboardModes, dataobject: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -1676,16 +1676,15 @@ impl IInkEdit { { (::windows_core::Interface::vtable(self).SetFactoid)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelInks(&self) -> ::windows_core::Result { + pub unsafe fn SelInks(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelInks)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelInks(&self, selink: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelInks)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(selink)).ok() + pub unsafe fn SetSelInks(&self, selink: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelInks)(::windows_core::Interface::as_raw(self), selink.into_param().abi()).ok() } pub unsafe fn SelInksDisplayMode(&self) -> ::windows_core::Result { let mut result__ = ::std::mem::zeroed(); @@ -1841,93 +1840,85 @@ impl IInkEdit { { (::windows_core::Interface::vtable(self).SetDisableNoScroll)(::windows_core::Interface::as_raw(self), newval.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelAlignment(&self) -> ::windows_core::Result { + pub unsafe fn SelAlignment(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelAlignment)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelAlignment(&self, pvarselalignment: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelAlignment)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselalignment)).ok() + pub unsafe fn SetSelAlignment(&self, pvarselalignment: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelAlignment)(::windows_core::Interface::as_raw(self), pvarselalignment.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelBold(&self) -> ::windows_core::Result { + pub unsafe fn SelBold(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelBold)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelBold(&self, pvarselbold: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelBold)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselbold)).ok() + pub unsafe fn SetSelBold(&self, pvarselbold: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelBold)(::windows_core::Interface::as_raw(self), pvarselbold.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelItalic(&self) -> ::windows_core::Result { + pub unsafe fn SelItalic(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelItalic)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelItalic(&self, pvarselitalic: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelItalic)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselitalic)).ok() + pub unsafe fn SetSelItalic(&self, pvarselitalic: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelItalic)(::windows_core::Interface::as_raw(self), pvarselitalic.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelUnderline(&self) -> ::windows_core::Result { + pub unsafe fn SelUnderline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelUnderline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelUnderline(&self, pvarselunderline: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelUnderline)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselunderline)).ok() + pub unsafe fn SetSelUnderline(&self, pvarselunderline: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelUnderline)(::windows_core::Interface::as_raw(self), pvarselunderline.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelColor(&self) -> ::windows_core::Result { + pub unsafe fn SelColor(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelColor)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelColor(&self, pvarselcolor: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelColor)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselcolor)).ok() + pub unsafe fn SetSelColor(&self, pvarselcolor: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelColor)(::windows_core::Interface::as_raw(self), pvarselcolor.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelFontName(&self) -> ::windows_core::Result { + pub unsafe fn SelFontName(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelFontName)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelFontName(&self, pvarselfontname: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelFontName)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselfontname)).ok() + pub unsafe fn SetSelFontName(&self, pvarselfontname: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelFontName)(::windows_core::Interface::as_raw(self), pvarselfontname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelFontSize(&self) -> ::windows_core::Result { + pub unsafe fn SelFontSize(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelFontSize)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelFontSize(&self, pvarselfontsize: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelFontSize)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselfontsize)).ok() + pub unsafe fn SetSelFontSize(&self, pvarselfontsize: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelFontSize)(::windows_core::Interface::as_raw(self), pvarselfontsize.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelCharOffset(&self) -> ::windows_core::Result { + pub unsafe fn SelCharOffset(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelCharOffset)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetSelCharOffset(&self, pvarselcharoffset: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetSelCharOffset)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(pvarselcharoffset)).ok() + pub unsafe fn SetSelCharOffset(&self, pvarselcharoffset: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetSelCharOffset)(::windows_core::Interface::as_raw(self), pvarselcharoffset.into_param().abi()).ok() } pub unsafe fn TextRTF(&self) -> ::windows_core::Result<::windows_core::BSTR> { let mut result__ = ::std::mem::zeroed(); @@ -2009,14 +2000,8 @@ pub struct IInkEdit_Vtbl { putref_Recognizer: usize, pub Factoid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetFactoid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelInks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pselink: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelInks: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelInks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, selink: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelInks: usize, + pub SelInks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pselink: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelInks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, selink: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SelInksDisplayMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pinkdisplaymode: *mut InkDisplayMode) -> ::windows_core::HRESULT, pub SetSelInksDisplayMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, inkdisplaymode: InkDisplayMode) -> ::windows_core::HRESULT, pub Recognize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -2068,70 +2053,22 @@ pub struct IInkEdit_Vtbl { pub SetScrollBars: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: ScrollBarsConstants) -> ::windows_core::HRESULT, pub DisableNoScroll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetDisableNoScroll: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, newval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelAlignment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselalignment: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelAlignment: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelAlignment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselalignment: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelAlignment: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelBold: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselbold: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelBold: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelBold: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselbold: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelBold: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelItalic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselitalic: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelItalic: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelItalic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselitalic: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelItalic: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelUnderline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselunderline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelUnderline: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelUnderline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselunderline: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelUnderline: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelColor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcolor: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelColor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelColor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcolor: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelColor: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelFontName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontname: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelFontName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelFontName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontname: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelFontName: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelFontSize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontsize: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelFontSize: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelFontSize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontsize: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelFontSize: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelCharOffset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcharoffset: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelCharOffset: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetSelCharOffset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcharoffset: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetSelCharOffset: usize, + pub SelAlignment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselalignment: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelAlignment: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselalignment: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelBold: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselbold: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelBold: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselbold: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelItalic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselitalic: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelItalic: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselitalic: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelUnderline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselunderline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelUnderline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselunderline: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelColor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcolor: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelColor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcolor: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelFontName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontname: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelFontName: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontname: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelFontSize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontsize: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelFontSize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselfontsize: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelCharOffset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcharoffset: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetSelCharOffset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarselcharoffset: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub TextRTF: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrtextrtf: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SetTextRTF: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrtextrtf: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub SelStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plselstart: *mut i32) -> ::windows_core::HRESULT, @@ -2163,25 +2100,30 @@ impl IInkExtendedProperties { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self)._NewEnum)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Item(&self, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::Result { + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Item(&self, identifier: P0) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(identifier), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Item)(::windows_core::Interface::as_raw(self), identifier.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Add(&self, guid: P0, data: super::super::System::Variant::VARIANT) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn Add(&self, guid: P0, data: P1) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), guid.into_param().abi(), ::core::mem::transmute(data), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Add)(::windows_core::Interface::as_raw(self), guid.into_param().abi(), data.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Remove(&self, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(identifier)).ok() + pub unsafe fn Remove(&self, identifier: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).Remove)(::windows_core::Interface::as_raw(self), identifier.into_param().abi()).ok() } pub unsafe fn Clear(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Clear)(::windows_core::Interface::as_raw(self)).ok() @@ -2201,18 +2143,15 @@ pub struct IInkExtendedProperties_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Count: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, count: *mut i32) -> ::windows_core::HRESULT, pub _NewEnum: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, _newenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT, item: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Item: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>, item: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Item: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>, data: super::super::System::Variant::VARIANT, inkextendedproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub Add: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>, inkextendedproperty: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] Add: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Remove: usize, + pub Remove: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, identifier: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub DoesPropertyExist: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: ::std::mem::MaybeUninit<::windows_core::BSTR>, doespropertyexist: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, } @@ -2231,16 +2170,15 @@ impl IInkExtendedProperty { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Guid)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Data(&self) -> ::windows_core::Result { + pub unsafe fn Data(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Data)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetData(&self, data: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetData)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(data)).ok() + pub unsafe fn SetData(&self, data: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetData)(::windows_core::Interface::as_raw(self), data.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -2249,14 +2187,8 @@ impl IInkExtendedProperty { pub struct IInkExtendedProperty_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Guid: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, guid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Data: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Data: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetData: usize, + pub Data: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, data: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -2430,16 +2362,15 @@ impl IInkOverlay { { (::windows_core::Interface::vtable(self).SetDynamicRendering)(::windows_core::Interface::as_raw(self), enabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result { + pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DesiredPacketDescription)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDesiredPacketDescription(&self, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(packetguids)).ok() + pub unsafe fn SetDesiredPacketDescription(&self, packetguids: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), packetguids.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] @@ -2658,14 +2589,8 @@ pub struct IInkOverlay_Vtbl { pub SetCollectionMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mode: InkCollectionMode) -> ::windows_core::HRESULT, pub DynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetDynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DesiredPacketDescription: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDesiredPacketDescription: usize, + pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub MouseIcon: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mouseicon: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole")))] @@ -2823,16 +2748,15 @@ impl IInkPicture { { (::windows_core::Interface::vtable(self).SetDynamicRendering)(::windows_core::Interface::as_raw(self), enabled.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result { + pub unsafe fn DesiredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).DesiredPacketDescription)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetDesiredPacketDescription(&self, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(packetguids)).ok() + pub unsafe fn SetDesiredPacketDescription(&self, packetguids: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetDesiredPacketDescription)(::windows_core::Interface::as_raw(self), packetguids.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`"] #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] @@ -3089,14 +3013,8 @@ pub struct IInkPicture_Vtbl { pub SetCollectionMode: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mode: InkCollectionMode) -> ::windows_core::HRESULT, pub DynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SetDynamicRendering: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, enabled: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - DesiredPacketDescription: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetDesiredPacketDescription: usize, + pub DesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetDesiredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetguids: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub MouseIcon: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, mouseicon: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole")))] @@ -3199,27 +3117,19 @@ impl IInkRecognitionAlternate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Confidence)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Baseline(&self) -> ::windows_core::Result { + pub unsafe fn Baseline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Baseline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Midline(&self) -> ::windows_core::Result { + pub unsafe fn Midline(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Midline)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Ascender(&self) -> ::windows_core::Result { + pub unsafe fn Ascender(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Ascender)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Descender(&self) -> ::windows_core::Result { + pub unsafe fn Descender(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Descender)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3276,9 +3186,7 @@ impl IInkRecognitionAlternate { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).AlternatesWithConstantPropertyValues)(::windows_core::Interface::as_raw(self), propertytype.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPropertyValue(&self, propertytype: P0) -> ::windows_core::Result + pub unsafe fn GetPropertyValue(&self, propertytype: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { @@ -3293,22 +3201,10 @@ pub struct IInkRecognitionAlternate_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub String: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, recostring: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Confidence: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, confidence: *mut InkRecognitionConfidence) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Baseline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, baseline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Baseline: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Midline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, midline: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Midline: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Ascender: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ascender: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Ascender: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Descender: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, descender: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Descender: usize, + pub Baseline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, baseline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Midline: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, midline: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Ascender: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ascender: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub Descender: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, descender: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub LineNumber: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, linenumber: *mut i32) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Strokes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokes: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -3338,10 +3234,7 @@ pub struct IInkRecognitionAlternate_Vtbl { pub AlternatesWithConstantPropertyValues: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertytype: ::std::mem::MaybeUninit<::windows_core::BSTR>, alternateswithconstantpropertyvalues: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] AlternatesWithConstantPropertyValues: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertytype: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPropertyValue: usize, + pub GetPropertyValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertytype: ::std::mem::MaybeUninit<::windows_core::BSTR>, propertyvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3488,21 +3381,15 @@ impl IInkRecognizer { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Capabilities)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Languages(&self) -> ::windows_core::Result { + pub unsafe fn Languages(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Languages)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SupportedProperties(&self) -> ::windows_core::Result { + pub unsafe fn SupportedProperties(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SupportedProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PreferredPacketDescription(&self) -> ::windows_core::Result { + pub unsafe fn PreferredPacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PreferredPacketDescription)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3521,18 +3408,9 @@ pub struct IInkRecognizer_Vtbl { pub Name: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Vendor: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vendor: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Capabilities: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, capabilitiesflags: *mut InkRecognizerCapabilities) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Languages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, languages: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Languages: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SupportedProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, supportedproperties: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SupportedProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PreferredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, preferredpacketdescription: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PreferredPacketDescription: usize, + pub Languages: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, languages: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SupportedProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, supportedproperties: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub PreferredPacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, preferredpacketdescription: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub CreateRecognizerContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, context: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3553,9 +3431,7 @@ impl IInkRecognizer2 { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Id)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn UnicodeRanges(&self) -> ::windows_core::Result { + pub unsafe fn UnicodeRanges(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).UnicodeRanges)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -3566,10 +3442,7 @@ impl IInkRecognizer2 { pub struct IInkRecognizer2_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub Id: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub UnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - UnicodeRanges: usize, + pub UnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -3685,15 +3558,17 @@ impl IInkRecognizerContext { pub unsafe fn EndInkInput(&self) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).EndInkInput)(::windows_core::Interface::as_raw(self)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BackgroundRecognize(&self, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).BackgroundRecognize)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(customdata)).ok() + pub unsafe fn BackgroundRecognize(&self, customdata: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).BackgroundRecognize)(::windows_core::Interface::as_raw(self), customdata.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BackgroundRecognizeWithAlternates(&self, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).BackgroundRecognizeWithAlternates)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(customdata)).ok() + pub unsafe fn BackgroundRecognizeWithAlternates(&self, customdata: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).BackgroundRecognizeWithAlternates)(::windows_core::Interface::as_raw(self), customdata.into_param().abi()).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -3758,14 +3633,8 @@ pub struct IInkRecognizerContext_Vtbl { Recognize: usize, pub StopBackgroundRecognition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub EndInkInput: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BackgroundRecognize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BackgroundRecognize: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BackgroundRecognizeWithAlternates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, customdata: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BackgroundRecognizeWithAlternates: usize, + pub BackgroundRecognize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, customdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub BackgroundRecognizeWithAlternates: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, customdata: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, recocontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -3783,16 +3652,15 @@ pub struct IInkRecognizerContext_Vtbl { ::windows_core::imp::interface_hierarchy!(IInkRecognizerContext2, ::windows_core::IUnknown, super::super::System::Com::IDispatch); #[cfg(feature = "Win32_System_Com")] impl IInkRecognizerContext2 { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn EnabledUnicodeRanges(&self) -> ::windows_core::Result { + pub unsafe fn EnabledUnicodeRanges(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).EnabledUnicodeRanges)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetEnabledUnicodeRanges(&self, unicoderanges: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetEnabledUnicodeRanges)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(unicoderanges)).ok() + pub unsafe fn SetEnabledUnicodeRanges(&self, unicoderanges: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetEnabledUnicodeRanges)(::windows_core::Interface::as_raw(self), unicoderanges.into_param().abi()).ok() } } #[cfg(feature = "Win32_System_Com")] @@ -3800,14 +3668,8 @@ impl IInkRecognizerContext2 { #[doc(hidden)] pub struct IInkRecognizerContext2_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub EnabledUnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - EnabledUnicodeRanges: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetEnabledUnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetEnabledUnicodeRanges: usize, + pub EnabledUnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetEnabledUnicodeRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, unicoderanges: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] ::windows_core::imp::com_interface!( @@ -4091,15 +3953,11 @@ impl IInkRenderer { pub unsafe fn InkSpaceToPixel(&self, hdcdisplay: isize, x: *mut i32, y: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).InkSpaceToPixel)(::windows_core::Interface::as_raw(self), hdcdisplay, x, y).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PixelToInkSpaceFromPoints(&self, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).PixelToInkSpaceFromPoints)(::windows_core::Interface::as_raw(self), hdc, points).ok() + pub unsafe fn PixelToInkSpaceFromPoints(&self, hdc: isize, points: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).PixelToInkSpaceFromPoints)(::windows_core::Interface::as_raw(self), hdc, ::core::mem::transmute(points)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn InkSpaceToPixelFromPoints(&self, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).InkSpaceToPixelFromPoints)(::windows_core::Interface::as_raw(self), hdc, points).ok() + pub unsafe fn InkSpaceToPixelFromPoints(&self, hdc: isize, points: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).InkSpaceToPixelFromPoints)(::windows_core::Interface::as_raw(self), hdc, ::core::mem::transmute(points)).ok() } #[doc = "Required features: `\"Win32_System_Com\"`"] #[cfg(feature = "Win32_System_Com")] @@ -4164,14 +4022,8 @@ pub struct IInkRenderer_Vtbl { DrawStroke: usize, pub PixelToInkSpace: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdc: isize, x: *mut i32, y: *mut i32) -> ::windows_core::HRESULT, pub InkSpaceToPixel: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdcdisplay: isize, x: *mut i32, y: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PixelToInkSpaceFromPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PixelToInkSpaceFromPoints: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub InkSpaceToPixelFromPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - InkSpaceToPixelFromPoints: usize, + pub PixelToInkSpaceFromPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub InkSpaceToPixelFromPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, hdc: isize, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Measure: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokes: *mut ::core::ffi::c_void, rectangle: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4199,9 +4051,7 @@ impl IInkStrokeDisp { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ID)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BezierPoints(&self) -> ::windows_core::Result { + pub unsafe fn BezierPoints(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BezierPoints)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4231,21 +4081,15 @@ impl IInkStrokeDisp { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).ExtendedProperties)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PolylineCusps(&self) -> ::windows_core::Result { + pub unsafe fn PolylineCusps(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PolylineCusps)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn BezierCusps(&self) -> ::windows_core::Result { + pub unsafe fn BezierCusps(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).BezierCusps)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SelfIntersections(&self) -> ::windows_core::Result { + pub unsafe fn SelfIntersections(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).SelfIntersections)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4257,9 +4101,7 @@ impl IInkStrokeDisp { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PacketSize)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn PacketDescription(&self) -> ::windows_core::Result { + pub unsafe fn PacketDescription(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).PacketDescription)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4273,18 +4115,18 @@ impl IInkStrokeDisp { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetBoundingBox)(::windows_core::Interface::as_raw(self), boundingboxmode, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn FindIntersections(&self, strokes: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn FindIntersections(&self, strokes: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).FindIntersections)(::windows_core::Interface::as_raw(self), strokes.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetRectangleIntersections(&self, rectangle: P0) -> ::windows_core::Result + #[doc = "Required features: `\"Win32_System_Com\"`"] + #[cfg(feature = "Win32_System_Com")] + pub unsafe fn GetRectangleIntersections(&self, rectangle: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -4318,45 +4160,37 @@ impl IInkStrokeDisp { { (::windows_core::Interface::vtable(self).GetPacketDescriptionPropertyMetrics)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), minimum, maximum, units, resolution).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPoints(&self, index: i32, count: i32) -> ::windows_core::Result { + pub unsafe fn GetPoints(&self, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPoints)(::windows_core::Interface::as_raw(self), index, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPoints(&self, points: super::super::System::Variant::VARIANT, index: i32, count: i32) -> ::windows_core::Result { + pub unsafe fn SetPoints(&self, points: P0, index: i32, count: i32) -> ::windows_core::Result + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).SetPoints)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(points), index, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).SetPoints)(::windows_core::Interface::as_raw(self), points.into_param().abi(), index, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPacketData(&self, index: i32, count: i32) -> ::windows_core::Result { + pub unsafe fn GetPacketData(&self, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPacketData)(::windows_core::Interface::as_raw(self), index, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetPacketValuesByProperty(&self, propertyname: P0, index: i32, count: i32) -> ::windows_core::Result + pub unsafe fn GetPacketValuesByProperty(&self, propertyname: P0, index: i32, count: i32) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetPacketValuesByProperty)(::windows_core::Interface::as_raw(self), propertyname.into_param().abi(), index, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetPacketValuesByProperty(&self, bstrpropertyname: P0, packetvalues: super::super::System::Variant::VARIANT, index: i32, count: i32) -> ::windows_core::Result + pub unsafe fn SetPacketValuesByProperty(&self, bstrpropertyname: P0, packetvalues: P1, index: i32, count: i32) -> ::windows_core::Result where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).SetPacketValuesByProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), ::core::mem::transmute(packetvalues), index, count, &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).SetPacketValuesByProperty)(::windows_core::Interface::as_raw(self), bstrpropertyname.into_param().abi(), packetvalues.into_param().abi(), index, count, &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetFlattenedBezierPoints(&self, fittingerror: i32) -> ::windows_core::Result { + pub unsafe fn GetFlattenedBezierPoints(&self, fittingerror: i32) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetFlattenedBezierPoints)(::windows_core::Interface::as_raw(self), fittingerror, &mut result__).from_abi(result__) } @@ -4396,10 +4230,7 @@ impl IInkStrokeDisp { pub struct IInkStrokeDisp_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub ID: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, id: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BezierPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BezierPoints: usize, + pub BezierPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub DrawingAttributes: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, drawattrs: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -4416,36 +4247,24 @@ pub struct IInkStrokeDisp_Vtbl { pub ExtendedProperties: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, properties: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] ExtendedProperties: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PolylineCusps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cusps: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PolylineCusps: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub BezierCusps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cusps: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - BezierCusps: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SelfIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SelfIntersections: usize, + pub PolylineCusps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cusps: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub BezierCusps: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, cusps: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SelfIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub PacketCount: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plcount: *mut i32) -> ::windows_core::HRESULT, pub PacketSize: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, plsize: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub PacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetdescription: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - PacketDescription: usize, + pub PacketDescription: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, packetdescription: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Deleted: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, deleted: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub GetBoundingBox: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, boundingboxmode: InkBoundingBoxMode, rectangle: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] GetBoundingBox: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub FindIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokes: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub FindIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strokes: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] FindIntersections: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetRectangleIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void, intersections: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] + #[cfg(feature = "Win32_System_Com")] + pub GetRectangleIntersections: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void, intersections: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + #[cfg(not(feature = "Win32_System_Com"))] GetRectangleIntersections: usize, #[cfg(feature = "Win32_System_Com")] pub Clip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rectangle: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4458,30 +4277,12 @@ pub struct IInkStrokeDisp_Vtbl { #[cfg(not(feature = "Win32_System_Com"))] Split: usize, pub GetPacketDescriptionPropertyMetrics: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, minimum: *mut i32, maximum: *mut i32, units: *mut TabletPropertyMetricUnit, resolution: *mut f32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, count: i32, points: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPoints: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: super::super::System::Variant::VARIANT, index: i32, count: i32, numberofpointsset: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPoints: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPacketData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, count: i32, packetdata: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPacketData: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetPacketValuesByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, index: i32, count: i32, packetvalues: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetPacketValuesByProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetPacketValuesByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, packetvalues: super::super::System::Variant::VARIANT, index: i32, count: i32, numberofpacketsset: *mut i32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetPacketValuesByProperty: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetFlattenedBezierPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fittingerror: i32, flattenedbezierpoints: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetFlattenedBezierPoints: usize, + pub GetPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, count: i32, points: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, points: ::std::mem::MaybeUninit<::windows_core::VARIANT>, index: i32, count: i32, numberofpointsset: *mut i32) -> ::windows_core::HRESULT, + pub GetPacketData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, index: i32, count: i32, packetdata: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetPacketValuesByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, propertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, index: i32, count: i32, packetvalues: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub SetPacketValuesByProperty: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrpropertyname: ::std::mem::MaybeUninit<::windows_core::BSTR>, packetvalues: ::std::mem::MaybeUninit<::windows_core::VARIANT>, index: i32, count: i32, numberofpacketsset: *mut i32) -> ::windows_core::HRESULT, + pub GetFlattenedBezierPoints: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, fittingerror: i32, flattenedbezierpoints: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, #[cfg(feature = "Win32_System_Com")] pub Transform: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, transform: *mut ::core::ffi::c_void, applyonpenwidth: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] @@ -9175,25 +8976,39 @@ impl ::windows_core::TypeKind for HRECOWORDLIST { type TypeKind = ::windows_core::CopyType; } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`, `\"Win32_UI_Controls\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls"))] +#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_UI_Controls\"`"] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] pub struct IEC_GESTUREINFO { pub nmhdr: super::Controls::NMHDR, pub Cursor: ::std::mem::ManuallyDrop<::core::option::Option>, pub Strokes: ::std::mem::ManuallyDrop<::core::option::Option>, - pub Gestures: super::super::System::Variant::VARIANT, + pub Gestures: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] impl ::core::clone::Clone for IEC_GESTUREINFO { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] +impl ::core::fmt::Debug for IEC_GESTUREINFO { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("IEC_GESTUREINFO").field("nmhdr", &self.nmhdr).field("Cursor", &self.Cursor).field("Strokes", &self.Strokes).field("Gestures", &self.Gestures).finish() + } +} +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] impl ::windows_core::TypeKind for IEC_GESTUREINFO { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant", feature = "Win32_UI_Controls"))] +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] +impl ::core::cmp::PartialEq for IEC_GESTUREINFO { + fn eq(&self, other: &Self) -> bool { + self.nmhdr == other.nmhdr && self.Cursor == other.Cursor && self.Strokes == other.Strokes && self.Gestures == other.Gestures + } +} +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] +impl ::core::cmp::Eq for IEC_GESTUREINFO {} +#[cfg(all(feature = "Win32_System_Com", feature = "Win32_UI_Controls"))] impl ::core::default::Default for IEC_GESTUREINFO { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/UI/TextServices/impl.rs b/crates/libs/windows/src/Windows/Win32/UI/TextServices/impl.rs index b54185a4f5..7ffc9ebd48 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/TextServices/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/TextServices/impl.rs @@ -67,18 +67,14 @@ impl IAccClientDocMgr_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IAccDictionary_Impl: Sized { fn GetLocalizedString(&self, term: *const ::windows_core::GUID, lcid: u32, presult: *mut ::windows_core::BSTR, plcid: *mut u32) -> ::windows_core::Result<()>; fn GetParentTerm(&self, term: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::GUID>; fn GetMnemonicString(&self, term: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::BSTR>; fn LookupMnemonicTerm(&self, bstrmnemonic: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::GUID>; - fn ConvertValueToString(&self, term: *const ::windows_core::GUID, lcid: u32, varvalue: &super::super::System::Variant::VARIANT, pbstrresult: *mut ::windows_core::BSTR, plcid: *mut u32) -> ::windows_core::Result<()>; + fn ConvertValueToString(&self, term: *const ::windows_core::GUID, lcid: u32, varvalue: &::windows_core::VARIANT, pbstrresult: *mut ::windows_core::BSTR, plcid: *mut u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IAccDictionary {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IAccDictionary_Vtbl { pub const fn new, Impl: IAccDictionary_Impl, const OFFSET: isize>() -> IAccDictionary_Vtbl { unsafe extern "system" fn GetLocalizedString, Impl: IAccDictionary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, lcid: u32, presult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, plcid: *mut u32) -> ::windows_core::HRESULT { @@ -119,7 +115,7 @@ impl IAccDictionary_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn ConvertValueToString, Impl: IAccDictionary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, lcid: u32, varvalue: super::super::System::Variant::VARIANT, pbstrresult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, plcid: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn ConvertValueToString, Impl: IAccDictionary_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, lcid: u32, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrresult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, plcid: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.ConvertValueToString(::core::mem::transmute_copy(&term), ::core::mem::transmute_copy(&lcid), ::core::mem::transmute(&varvalue), ::core::mem::transmute_copy(&pbstrresult), ::core::mem::transmute_copy(&plcid)).into() @@ -404,17 +400,13 @@ impl IClonableWrapper_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ICoCreateLocally_Impl: Sized { - fn CoCreateLocally(&self, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut ::core::option::Option<::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: ::core::option::Option<&::windows_core::IUnknown>, varparam: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn CoCreateLocally(&self, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut ::core::option::Option<::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: ::core::option::Option<&::windows_core::IUnknown>, varparam: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ICoCreateLocally {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ICoCreateLocally_Vtbl { pub const fn new, Impl: ICoCreateLocally_Impl, const OFFSET: isize>() -> ICoCreateLocally_Vtbl { - unsafe extern "system" fn CoCreateLocally, Impl: ICoCreateLocally_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn CoCreateLocally, Impl: ICoCreateLocally_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.CoCreateLocally(::core::mem::transmute_copy(&rclsid), ::core::mem::transmute_copy(&dwclscontext), ::core::mem::transmute_copy(&riid), ::core::mem::transmute_copy(&punk), ::core::mem::transmute_copy(&riidparam), ::windows_core::from_raw_borrowed(&punkparam), ::core::mem::transmute(&varparam)).into() @@ -425,17 +417,13 @@ impl ICoCreateLocally_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ICoCreatedLocally_Impl: Sized { - fn LocalInit(&self, punklocalobject: ::core::option::Option<&::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: ::core::option::Option<&::windows_core::IUnknown>, varparam: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn LocalInit(&self, punklocalobject: ::core::option::Option<&::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: ::core::option::Option<&::windows_core::IUnknown>, varparam: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ICoCreatedLocally {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ICoCreatedLocally_Vtbl { pub const fn new, Impl: ICoCreatedLocally_Impl, const OFFSET: isize>() -> ICoCreatedLocally_Vtbl { - unsafe extern "system" fn LocalInit, Impl: ICoCreatedLocally_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punklocalobject: *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn LocalInit, Impl: ICoCreatedLocally_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punklocalobject: *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.LocalInit(::windows_core::from_raw_borrowed(&punklocalobject), ::core::mem::transmute_copy(&riidparam), ::windows_core::from_raw_borrowed(&punkparam), ::core::mem::transmute(&varparam)).into() @@ -1090,17 +1078,13 @@ impl IEnumTfProperties_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait IEnumTfPropertyValue_Impl: Sized { fn Clone(&self) -> ::windows_core::Result; fn Next(&self, ulcount: u32, rgvalues: *mut TF_PROPERTYVAL, pcfetched: *mut u32) -> ::windows_core::Result<()>; fn Reset(&self) -> ::windows_core::Result<()>; fn Skip(&self, ulcount: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for IEnumTfPropertyValue {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl IEnumTfPropertyValue_Vtbl { pub const fn new, Impl: IEnumTfPropertyValue_Impl, const OFFSET: isize>() -> IEnumTfPropertyValue_Vtbl { unsafe extern "system" fn Clone, Impl: IEnumTfPropertyValue_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1285,8 +1269,8 @@ impl ISpeechCommandProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStoreACP_Impl: Sized { fn AdviseSink(&self, riid: *const ::windows_core::GUID, punk: ::core::option::Option<&::windows_core::IUnknown>, dwmask: u32) -> ::windows_core::Result<()>; fn UnadviseSink(&self, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; @@ -1315,9 +1299,9 @@ pub trait ITextStoreACP_Impl: Sized { fn GetScreenExt(&self, vcview: u32) -> ::windows_core::Result; fn GetWnd(&self, vcview: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStoreACP {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStoreACP_Vtbl { pub const fn new, Impl: ITextStoreACP_Impl, const OFFSET: isize>() -> ITextStoreACP_Vtbl { unsafe extern "system" fn AdviseSink, Impl: ITextStoreACP_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, punk: *mut ::core::ffi::c_void, dwmask: u32) -> ::windows_core::HRESULT { @@ -1556,8 +1540,8 @@ impl ITextStoreACP_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStoreACP2_Impl: Sized { fn AdviseSink(&self, riid: *const ::windows_core::GUID, punk: ::core::option::Option<&::windows_core::IUnknown>, dwmask: u32) -> ::windows_core::Result<()>; fn UnadviseSink(&self, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; @@ -1585,9 +1569,9 @@ pub trait ITextStoreACP2_Impl: Sized { fn GetTextExt(&self, vcview: u32, acpstart: i32, acpend: i32, prc: *mut super::super::Foundation::RECT, pfclipped: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetScreenExt(&self, vcview: u32) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStoreACP2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStoreACP2_Vtbl { pub const fn new, Impl: ITextStoreACP2_Impl, const OFFSET: isize>() -> ITextStoreACP2_Vtbl { unsafe extern "system" fn AdviseSink, Impl: ITextStoreACP2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, punk: *mut ::core::ffi::c_void, dwmask: u32) -> ::windows_core::HRESULT { @@ -1968,8 +1952,8 @@ impl ITextStoreACPSinkEx_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITextStoreAnchor_Impl: Sized { fn AdviseSink(&self, riid: *const ::windows_core::GUID, punk: ::core::option::Option<&::windows_core::IUnknown>, dwmask: u32) -> ::windows_core::Result<()>; fn UnadviseSink(&self, punk: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; @@ -1999,9 +1983,9 @@ pub trait ITextStoreAnchor_Impl: Sized { fn InsertTextAtSelection(&self, dwflags: u32, pchtext: &::windows_core::PCWSTR, cch: u32, ppastart: *mut ::core::option::Option, ppaend: *mut ::core::option::Option) -> ::windows_core::Result<()>; fn InsertEmbeddedAtSelection(&self, dwflags: u32, pdataobject: ::core::option::Option<&super::super::System::Com::IDataObject>, ppastart: *mut ::core::option::Option, ppaend: *mut ::core::option::Option) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITextStoreAnchor {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITextStoreAnchor_Vtbl { pub const fn new, Impl: ITextStoreAnchor_Impl, const OFFSET: isize>() -> ITextStoreAnchor_Vtbl { unsafe extern "system" fn AdviseSink, Impl: ITextStoreAnchor_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, riid: *const ::windows_core::GUID, punk: *mut ::core::ffi::c_void, dwmask: u32) -> ::windows_core::HRESULT { @@ -2821,23 +2805,19 @@ impl ITfClientId_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITfCompartment_Impl: Sized { - fn SetValue(&self, tid: u32, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn GetValue(&self) -> ::windows_core::Result; + fn SetValue(&self, tid: u32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITfCompartment {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITfCompartment_Vtbl { pub const fn new, Impl: ITfCompartment_Impl, const OFFSET: isize>() -> ITfCompartment_Vtbl { - unsafe extern "system" fn SetValue, Impl: ITfCompartment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tid: u32, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ITfCompartment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, tid: u32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&tid), ::core::mem::transmute_copy(&pvarvalue)).into() } - unsafe extern "system" fn GetValue, Impl: ITfCompartment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ITfCompartment_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue() { @@ -3381,19 +3361,15 @@ impl ITfContextKeyEventSink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITfContextOwner_Impl: Sized { fn GetACPFromPoint(&self, ptscreen: *const super::super::Foundation::POINT, dwflags: u32) -> ::windows_core::Result; fn GetTextExt(&self, acpstart: i32, acpend: i32, prc: *mut super::super::Foundation::RECT, pfclipped: *mut super::super::Foundation::BOOL) -> ::windows_core::Result<()>; fn GetScreenExt(&self) -> ::windows_core::Result; fn GetStatus(&self) -> ::windows_core::Result; fn GetWnd(&self) -> ::windows_core::Result; - fn GetAttribute(&self, rguidattribute: *const ::windows_core::GUID) -> ::windows_core::Result; + fn GetAttribute(&self, rguidattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITfContextOwner {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITfContextOwner_Vtbl { pub const fn new, Impl: ITfContextOwner_Impl, const OFFSET: isize>() -> ITfContextOwner_Vtbl { unsafe extern "system" fn GetACPFromPoint, Impl: ITfContextOwner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ptscreen: *const super::super::Foundation::POINT, dwflags: u32, pacp: *mut i32) -> ::windows_core::HRESULT { @@ -3445,7 +3421,7 @@ impl ITfContextOwner_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetAttribute, Impl: ITfContextOwner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rguidattribute: *const ::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetAttribute, Impl: ITfContextOwner_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, rguidattribute: *const ::windows_core::GUID, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetAttribute(::core::mem::transmute_copy(&rguidattribute)) { @@ -6214,17 +6190,13 @@ impl ITfPreservedKeyNotifySink_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITfProperty_Impl: Sized + ITfReadOnlyProperty_Impl { fn FindRange(&self, ec: u32, prange: ::core::option::Option<&ITfRange>, pprange: *mut ::core::option::Option, apos: TfAnchor) -> ::windows_core::Result<()>; fn SetValueStore(&self, ec: u32, prange: ::core::option::Option<&ITfRange>, ppropstore: ::core::option::Option<&ITfPropertyStore>) -> ::windows_core::Result<()>; - fn SetValue(&self, ec: u32, prange: ::core::option::Option<&ITfRange>, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn SetValue(&self, ec: u32, prange: ::core::option::Option<&ITfRange>, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()>; fn Clear(&self, ec: u32, prange: ::core::option::Option<&ITfRange>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITfProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITfProperty_Vtbl { pub const fn new, Impl: ITfProperty_Impl, const OFFSET: isize>() -> ITfProperty_Vtbl { unsafe extern "system" fn FindRange, Impl: ITfProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pprange: *mut *mut ::core::ffi::c_void, apos: TfAnchor) -> ::windows_core::HRESULT { @@ -6237,7 +6209,7 @@ impl ITfProperty_Vtbl { let this = (*this).get_impl(); this.SetValueStore(::core::mem::transmute_copy(&ec), ::windows_core::from_raw_borrowed(&prange), ::windows_core::from_raw_borrowed(&ppropstore)).into() } - unsafe extern "system" fn SetValue, Impl: ITfProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetValue, Impl: ITfProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetValue(::core::mem::transmute_copy(&ec), ::windows_core::from_raw_borrowed(&prange), ::core::mem::transmute_copy(&pvarvalue)).into() @@ -6259,12 +6231,12 @@ impl ITfProperty_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ITfPropertyStore_Impl: Sized { fn GetType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn GetDataType(&self) -> ::windows_core::Result; - fn GetData(&self) -> ::windows_core::Result; + fn GetData(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn OnTextUpdated(&self, dwflags: u32, prangenew: ::core::option::Option<&ITfRange>) -> ::windows_core::Result; fn Shrink(&self, prangenew: ::core::option::Option<&ITfRange>) -> ::windows_core::Result; fn Divide(&self, prangethis: ::core::option::Option<&ITfRange>, prangenew: ::core::option::Option<&ITfRange>) -> ::windows_core::Result; @@ -6272,9 +6244,9 @@ pub trait ITfPropertyStore_Impl: Sized { fn GetPropertyRangeCreator(&self) -> ::windows_core::Result<::windows_core::GUID>; fn Serialize(&self, pstream: ::core::option::Option<&super::super::System::Com::IStream>) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ITfPropertyStore {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ITfPropertyStore_Vtbl { pub const fn new, Impl: ITfPropertyStore_Impl, const OFFSET: isize>() -> ITfPropertyStore_Vtbl { unsafe extern "system" fn GetType, Impl: ITfPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -6299,7 +6271,7 @@ impl ITfPropertyStore_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn GetData, Impl: ITfPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetData, Impl: ITfPropertyStore_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetData() { @@ -6711,17 +6683,13 @@ impl ITfRangeBackup_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITfReadOnlyProperty_Impl: Sized { fn GetType(&self) -> ::windows_core::Result<::windows_core::GUID>; fn EnumRanges(&self, ec: u32, ppenum: *mut ::core::option::Option, ptargetrange: ::core::option::Option<&ITfRange>) -> ::windows_core::Result<()>; - fn GetValue(&self, ec: u32, prange: ::core::option::Option<&ITfRange>) -> ::windows_core::Result; + fn GetValue(&self, ec: u32, prange: ::core::option::Option<&ITfRange>) -> ::windows_core::Result<::windows_core::VARIANT>; fn GetContext(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITfReadOnlyProperty {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITfReadOnlyProperty_Vtbl { pub const fn new, Impl: ITfReadOnlyProperty_Impl, const OFFSET: isize>() -> ITfReadOnlyProperty_Vtbl { unsafe extern "system" fn GetType, Impl: ITfReadOnlyProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pguid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT { @@ -6740,7 +6708,7 @@ impl ITfReadOnlyProperty_Vtbl { let this = (*this).get_impl(); this.EnumRanges(::core::mem::transmute_copy(&ec), ::core::mem::transmute_copy(&ppenum), ::windows_core::from_raw_borrowed(&ptargetrange)).into() } - unsafe extern "system" fn GetValue, Impl: ITfReadOnlyProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetValue, Impl: ITfReadOnlyProperty_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetValue(::core::mem::transmute_copy(&ec), ::windows_core::from_raw_borrowed(&prange)) { diff --git a/crates/libs/windows/src/Windows/Win32/UI/TextServices/mod.rs b/crates/libs/windows/src/Windows/Win32/UI/TextServices/mod.rs index 644a1e97c8..d585e0023e 100644 --- a/crates/libs/windows/src/Windows/Win32/UI/TextServices/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/UI/TextServices/mod.rs @@ -74,10 +74,11 @@ impl IAccDictionary { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).LookupMnemonicTerm)(::windows_core::Interface::as_raw(self), bstrmnemonic.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn ConvertValueToString(&self, term: *const ::windows_core::GUID, lcid: u32, varvalue: super::super::System::Variant::VARIANT, pbstrresult: *mut ::windows_core::BSTR, plcid: *mut u32) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).ConvertValueToString)(::windows_core::Interface::as_raw(self), term, lcid, ::core::mem::transmute(varvalue), ::core::mem::transmute(pbstrresult), plcid).ok() + pub unsafe fn ConvertValueToString(&self, term: *const ::windows_core::GUID, lcid: u32, varvalue: P0, pbstrresult: *mut ::windows_core::BSTR, plcid: *mut u32) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).ConvertValueToString)(::windows_core::Interface::as_raw(self), term, lcid, varvalue.into_param().abi(), ::core::mem::transmute(pbstrresult), plcid).ok() } } #[repr(C)] @@ -88,10 +89,7 @@ pub struct IAccDictionary_Vtbl { pub GetParentTerm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, pparentterm: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetMnemonicString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, presult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub LookupMnemonicTerm: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrmnemonic: ::std::mem::MaybeUninit<::windows_core::BSTR>, pterm: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub ConvertValueToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, lcid: u32, varvalue: super::super::System::Variant::VARIANT, pbstrresult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, plcid: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - ConvertValueToString: usize, + pub ConvertValueToString: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, term: *const ::windows_core::GUID, lcid: u32, varvalue: ::std::mem::MaybeUninit<::windows_core::VARIANT>, pbstrresult: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>, plcid: *mut u32) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IAccServerDocMgr, IAccServerDocMgr_Vtbl, 0xad7c73cf_6dd5_4855_abc2_b04bad5b9153); ::windows_core::imp::interface_hierarchy!(IAccServerDocMgr, ::windows_core::IUnknown); @@ -272,45 +270,37 @@ pub struct IClonableWrapper_Vtbl { ::windows_core::imp::com_interface!(ICoCreateLocally, ICoCreateLocally_Vtbl, 0x03de00aa_f272_41e3_99cb_03c5e8114ea0); ::windows_core::imp::interface_hierarchy!(ICoCreateLocally, ::windows_core::IUnknown); impl ICoCreateLocally { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn CoCreateLocally(&self, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut ::core::option::Option<::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: P0, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn CoCreateLocally(&self, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut ::core::option::Option<::windows_core::IUnknown>, riidparam: *const ::windows_core::GUID, punkparam: P0, varparam: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).CoCreateLocally)(::windows_core::Interface::as_raw(self), rclsid, dwclscontext, riid, ::core::mem::transmute(punk), riidparam, punkparam.into_param().abi(), ::core::mem::transmute(varparam)).ok() + (::windows_core::Interface::vtable(self).CoCreateLocally)(::windows_core::Interface::as_raw(self), rclsid, dwclscontext, riid, ::core::mem::transmute(punk), riidparam, punkparam.into_param().abi(), varparam.into_param().abi()).ok() } } #[repr(C)] #[doc(hidden)] pub struct ICoCreateLocally_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub CoCreateLocally: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - CoCreateLocally: usize, + pub CoCreateLocally: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rclsid: *const ::windows_core::GUID, dwclscontext: u32, riid: *const ::windows_core::GUID, punk: *mut *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ICoCreatedLocally, ICoCreatedLocally_Vtbl, 0x0a53eb6c_1908_4742_8cff_2cee2e93f94c); ::windows_core::imp::interface_hierarchy!(ICoCreatedLocally, ::windows_core::IUnknown); impl ICoCreatedLocally { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn LocalInit(&self, punklocalobject: P0, riidparam: *const ::windows_core::GUID, punkparam: P1, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn LocalInit(&self, punklocalobject: P0, riidparam: *const ::windows_core::GUID, punkparam: P1, varparam: P2) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::IUnknown>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).LocalInit)(::windows_core::Interface::as_raw(self), punklocalobject.into_param().abi(), riidparam, punkparam.into_param().abi(), ::core::mem::transmute(varparam)).ok() + (::windows_core::Interface::vtable(self).LocalInit)(::windows_core::Interface::as_raw(self), punklocalobject.into_param().abi(), riidparam, punkparam.into_param().abi(), varparam.into_param().abi()).ok() } } #[repr(C)] #[doc(hidden)] pub struct ICoCreatedLocally_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub LocalInit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punklocalobject: *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - LocalInit: usize, + pub LocalInit: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punklocalobject: *mut ::core::ffi::c_void, riidparam: *const ::windows_core::GUID, punkparam: *mut ::core::ffi::c_void, varparam: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IDocWrap, IDocWrap_Vtbl, 0xdcd285fe_0be0_43bd_99c9_aaaec513c555); ::windows_core::imp::interface_hierarchy!(IDocWrap, ::windows_core::IUnknown); @@ -678,8 +668,6 @@ impl IEnumTfPropertyValue { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).Clone)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn Next(&self, rgvalues: &mut [TF_PROPERTYVAL], pcfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Next)(::windows_core::Interface::as_raw(self), rgvalues.len().try_into().unwrap(), ::core::mem::transmute(rgvalues.as_ptr()), pcfetched).ok() } @@ -695,10 +683,7 @@ impl IEnumTfPropertyValue { pub struct IEnumTfPropertyValue_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub Clone: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppenum: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub Next: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulcount: u32, rgvalues: *mut TF_PROPERTYVAL, pcfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Next: usize, pub Reset: unsafe extern "system" fn(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub Skip: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulcount: u32) -> ::windows_core::HRESULT, } @@ -872,8 +857,6 @@ impl ITextStoreACP { pub unsafe fn FindNextAttrTransition(&self, acpstart: i32, acphalt: i32, pafilterattrs: &[::windows_core::GUID], dwflags: u32, pacpnext: *mut i32, pffound: *mut super::super::Foundation::BOOL, plfoundoffset: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).FindNextAttrTransition)(::windows_core::Interface::as_raw(self), acpstart, acphalt, pafilterattrs.len().try_into().unwrap(), ::core::mem::transmute(pafilterattrs.as_ptr()), dwflags, pacpnext, pffound, plfoundoffset).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn RetrieveRequestedAttrs(&self, paattrvals: &mut [TS_ATTRVAL], pcfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RetrieveRequestedAttrs)(::windows_core::Interface::as_raw(self), paattrvals.len().try_into().unwrap(), ::core::mem::transmute(paattrvals.as_ptr()), pcfetched).ok() } @@ -936,10 +919,7 @@ pub struct ITextStoreACP_Vtbl { pub RequestAttrsAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acppos: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub RequestAttrsTransitioningAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acppos: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub FindNextAttrTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acpstart: i32, acphalt: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32, pacpnext: *mut i32, pffound: *mut super::super::Foundation::BOOL, plfoundoffset: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub RetrieveRequestedAttrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulcount: u32, paattrvals: *mut TS_ATTRVAL, pcfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RetrieveRequestedAttrs: usize, pub GetEndACP: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pacp: *mut i32) -> ::windows_core::HRESULT, pub GetActiveView: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvcview: *mut u32) -> ::windows_core::HRESULT, pub GetACPFromPoint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcview: u32, ptscreen: *const super::super::Foundation::POINT, dwflags: u32, pacp: *mut i32) -> ::windows_core::HRESULT, @@ -1034,8 +1014,6 @@ impl ITextStoreACP2 { pub unsafe fn FindNextAttrTransition(&self, acpstart: i32, acphalt: i32, pafilterattrs: &[::windows_core::GUID], dwflags: u32, pacpnext: *mut i32, pffound: *mut super::super::Foundation::BOOL, plfoundoffset: *mut i32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).FindNextAttrTransition)(::windows_core::Interface::as_raw(self), acpstart, acphalt, pafilterattrs.len().try_into().unwrap(), ::core::mem::transmute(pafilterattrs.as_ptr()), dwflags, pacpnext, pffound, plfoundoffset).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn RetrieveRequestedAttrs(&self, paattrvals: &mut [TS_ATTRVAL], pcfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RetrieveRequestedAttrs)(::windows_core::Interface::as_raw(self), paattrvals.len().try_into().unwrap(), ::core::mem::transmute(paattrvals.as_ptr()), pcfetched).ok() } @@ -1094,10 +1072,7 @@ pub struct ITextStoreACP2_Vtbl { pub RequestAttrsAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acppos: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub RequestAttrsTransitioningAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acppos: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub FindNextAttrTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, acpstart: i32, acphalt: i32, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32, pacpnext: *mut i32, pffound: *mut super::super::Foundation::BOOL, plfoundoffset: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub RetrieveRequestedAttrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulcount: u32, paattrvals: *mut TS_ATTRVAL, pcfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RetrieveRequestedAttrs: usize, pub GetEndACP: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pacp: *mut i32) -> ::windows_core::HRESULT, pub GetActiveView: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvcview: *mut u32) -> ::windows_core::HRESULT, pub GetACPFromPoint: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vcview: u32, ptscreen: *const super::super::Foundation::POINT, dwflags: u32, pacp: *mut i32) -> ::windows_core::HRESULT, @@ -1344,8 +1319,6 @@ impl ITextStoreAnchor { { (::windows_core::Interface::vtable(self).FindNextAttrTransition)(::windows_core::Interface::as_raw(self), pastart.into_param().abi(), pahalt.into_param().abi(), pafilterattrs.len().try_into().unwrap(), ::core::mem::transmute(pafilterattrs.as_ptr()), dwflags, pffound, plfoundoffset).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub unsafe fn RetrieveRequestedAttrs(&self, paattrvals: &mut [TS_ATTRVAL], pcfetched: *mut u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).RetrieveRequestedAttrs)(::windows_core::Interface::as_raw(self), paattrvals.len().try_into().unwrap(), ::core::mem::transmute(paattrvals.as_ptr()), pcfetched).ok() } @@ -1424,10 +1397,7 @@ pub struct ITextStoreAnchor_Vtbl { pub RequestAttrsAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, papos: *mut ::core::ffi::c_void, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub RequestAttrsTransitioningAtPosition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, papos: *mut ::core::ffi::c_void, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32) -> ::windows_core::HRESULT, pub FindNextAttrTransition: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pastart: *mut ::core::ffi::c_void, pahalt: *mut ::core::ffi::c_void, cfilterattrs: u32, pafilterattrs: *const ::windows_core::GUID, dwflags: u32, pffound: *mut super::super::Foundation::BOOL, plfoundoffset: *mut i32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub RetrieveRequestedAttrs: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ulcount: u32, paattrvals: *mut TS_ATTRVAL, pcfetched: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - RetrieveRequestedAttrs: usize, pub GetStart: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppastart: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetEnd: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppaend: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, pub GetActiveView: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvcview: *mut u32) -> ::windows_core::HRESULT, @@ -1885,14 +1855,10 @@ pub struct ITfClientId_Vtbl { ::windows_core::imp::com_interface!(ITfCompartment, ITfCompartment_Vtbl, 0xbb08f7a9_607a_4384_8623_056892b64371); ::windows_core::imp::interface_hierarchy!(ITfCompartment, ::windows_core::IUnknown); impl ITfCompartment { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, tid: u32, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), tid, pvarvalue).ok() + pub unsafe fn SetValue(&self, tid: u32, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), tid, ::core::mem::transmute(pvarvalue)).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self) -> ::windows_core::Result { + pub unsafe fn GetValue(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetValue)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1901,14 +1867,8 @@ impl ITfCompartment { #[doc(hidden)] pub struct ITfCompartment_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tid: u32, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, tid: u32, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITfCompartmentEventSink, ITfCompartmentEventSink_Vtbl, 0x743abd5f_f26d_48df_8cc5_238492419b64); ::windows_core::imp::interface_hierarchy!(ITfCompartmentEventSink, ::windows_core::IUnknown); @@ -2230,9 +2190,7 @@ impl ITfContextOwner { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetWnd)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetAttribute(&self, rguidattribute: *const ::windows_core::GUID) -> ::windows_core::Result { + pub unsafe fn GetAttribute(&self, rguidattribute: *const ::windows_core::GUID) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetAttribute)(::windows_core::Interface::as_raw(self), rguidattribute, &mut result__).from_abi(result__) } @@ -2246,10 +2204,7 @@ pub struct ITfContextOwner_Vtbl { pub GetScreenExt: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prc: *mut super::super::Foundation::RECT) -> ::windows_core::HRESULT, pub GetStatus: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdcs: *mut TS_STATUS) -> ::windows_core::HRESULT, pub GetWnd: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, phwnd: *mut super::super::Foundation::HWND) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rguidattribute: *const ::windows_core::GUID, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetAttribute: usize, + pub GetAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, rguidattribute: *const ::windows_core::GUID, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITfContextOwnerCompositionServices, ITfContextOwnerCompositionServices_Vtbl, 0x86462810_593b_4916_9764_19c08e9ce110); ::windows_core::imp::interface_hierarchy!(ITfContextOwnerCompositionServices, ::windows_core::IUnknown, ITfContextComposition); @@ -4371,9 +4326,7 @@ impl ITfProperty { { (::windows_core::Interface::vtable(self).base__.EnumRanges)(::windows_core::Interface::as_raw(self), ec, ::core::mem::transmute(ppenum), ptargetrange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, ec: u32, prange: P0) -> ::windows_core::Result + pub unsafe fn GetValue(&self, ec: u32, prange: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -4397,13 +4350,11 @@ impl ITfProperty { { (::windows_core::Interface::vtable(self).SetValueStore)(::windows_core::Interface::as_raw(self), ec, prange.into_param().abi(), ppropstore.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetValue(&self, ec: u32, prange: P0, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn SetValue(&self, ec: u32, prange: P0, pvarvalue: *const ::windows_core::VARIANT) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam, { - (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ec, prange.into_param().abi(), pvarvalue).ok() + (::windows_core::Interface::vtable(self).SetValue)(::windows_core::Interface::as_raw(self), ec, prange.into_param().abi(), ::core::mem::transmute(pvarvalue)).ok() } pub unsafe fn Clear(&self, ec: u32, prange: P0) -> ::windows_core::Result<()> where @@ -4418,10 +4369,7 @@ pub struct ITfProperty_Vtbl { pub base__: ITfReadOnlyProperty_Vtbl, pub FindRange: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pprange: *mut *mut ::core::ffi::c_void, apos: TfAnchor) -> ::windows_core::HRESULT, pub SetValueStore: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, ppropstore: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *const super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetValue: usize, + pub SetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *const ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub Clear: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITfPropertyStore, ITfPropertyStore_Vtbl, 0x6834b120_88cb_11d2_bf45_00105a2799b5); @@ -4435,9 +4383,7 @@ impl ITfPropertyStore { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetDataType)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetData(&self) -> ::windows_core::Result { + pub unsafe fn GetData(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetData)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -4487,10 +4433,7 @@ pub struct ITfPropertyStore_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub GetDataType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pdwreserved: *mut u32) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetData: usize, + pub GetData: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub OnTextUpdated: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwflags: u32, prangenew: *mut ::core::ffi::c_void, pfaccept: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Shrink: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prangenew: *mut ::core::ffi::c_void, pffree: *mut super::super::Foundation::BOOL) -> ::windows_core::HRESULT, pub Divide: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, prangethis: *mut ::core::ffi::c_void, prangenew: *mut ::core::ffi::c_void, pppropstore: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, @@ -4809,9 +4752,7 @@ impl ITfReadOnlyProperty { { (::windows_core::Interface::vtable(self).EnumRanges)(::windows_core::Interface::as_raw(self), ec, ::core::mem::transmute(ppenum), ptargetrange.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetValue(&self, ec: u32, prange: P0) -> ::windows_core::Result + pub unsafe fn GetValue(&self, ec: u32, prange: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam, { @@ -4829,10 +4770,7 @@ pub struct ITfReadOnlyProperty_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, pub GetType: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pguid: *mut ::windows_core::GUID) -> ::windows_core::HRESULT, pub EnumRanges: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, ppenum: *mut *mut ::core::ffi::c_void, ptargetrange: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetValue: usize, + pub GetValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ec: u32, prange: *mut ::core::ffi::c_void, pvarvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub GetContext: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ppcontext: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITfReadingInformationUIElement, ITfReadingInformationUIElement_Vtbl, 0xea1ea139_19df_11d7_a6d2_00065b84435c); @@ -7120,23 +7058,29 @@ impl ::core::default::Default for TF_PRESERVEDKEY { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct TF_PROPERTYVAL { pub guidId: ::windows_core::GUID, - pub varValue: super::super::System::Variant::VARIANT, + pub varValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for TF_PROPERTYVAL { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for TF_PROPERTYVAL { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("TF_PROPERTYVAL").field("guidId", &self.guidId).field("varValue", &self.varValue).finish() + } +} impl ::windows_core::TypeKind for TF_PROPERTYVAL { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for TF_PROPERTYVAL { + fn eq(&self, other: &Self) -> bool { + self.guidId == other.guidId && self.varValue == other.varValue + } +} +impl ::core::cmp::Eq for TF_PROPERTYVAL {} impl ::core::default::Default for TF_PROPERTYVAL { fn default() -> Self { unsafe { ::core::mem::zeroed() } @@ -7202,24 +7146,30 @@ impl ::core::default::Default for TF_SELECTIONSTYLE { } } #[repr(C)] -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub struct TS_ATTRVAL { pub idAttr: ::windows_core::GUID, pub dwOverlapId: u32, - pub varValue: super::super::System::Variant::VARIANT, + pub varValue: ::std::mem::ManuallyDrop<::windows_core::VARIANT>, } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::core::clone::Clone for TS_ATTRVAL { fn clone(&self) -> Self { unsafe { ::core::mem::transmute_copy(self) } } } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::fmt::Debug for TS_ATTRVAL { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_struct("TS_ATTRVAL").field("idAttr", &self.idAttr).field("dwOverlapId", &self.dwOverlapId).field("varValue", &self.varValue).finish() + } +} impl ::windows_core::TypeKind for TS_ATTRVAL { type TypeKind = ::windows_core::CopyType; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +impl ::core::cmp::PartialEq for TS_ATTRVAL { + fn eq(&self, other: &Self) -> bool { + self.idAttr == other.idAttr && self.dwOverlapId == other.dwOverlapId && self.varValue == other.varValue + } +} +impl ::core::cmp::Eq for TS_ATTRVAL {} impl ::core::default::Default for TS_ATTRVAL { fn default() -> Self { unsafe { ::core::mem::zeroed() } diff --git a/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/impl.rs b/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/impl.rs index 6e769fd8c1..38b0ed9461 100644 --- a/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/impl.rs +++ b/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/impl.rs @@ -93,14 +93,14 @@ impl IActiveXUIHandlerSite3_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IAnchorClick_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ProcOnClick(&self) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IAnchorClick {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IAnchorClick_Vtbl { pub const fn new, Impl: IAnchorClick_Impl, const OFFSET: isize>() -> IAnchorClick_Vtbl { unsafe extern "system" fn ProcOnClick, Impl: IAnchorClick_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -171,12 +171,12 @@ impl ICaretPositionProvider_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDeviceRect_Impl: Sized + super::super::System::Com::IDispatch_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDeviceRect {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDeviceRect_Vtbl { pub const fn new, Impl: IDeviceRect_Impl, const OFFSET: isize>() -> IDeviceRect_Vtbl { Self { base__: super::super::System::Com::IDispatch_Vtbl::new::() } @@ -327,14 +327,14 @@ impl IDocObjectService_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IDownloadBehavior_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn startDownload(&self, bstrurl: &::windows_core::BSTR, pdispcallback: ::core::option::Option<&super::super::System::Com::IDispatch>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IDownloadBehavior {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IDownloadBehavior_Vtbl { pub const fn new, Impl: IDownloadBehavior_Impl, const OFFSET: isize>() -> IDownloadBehavior_Vtbl { unsafe extern "system" fn startDownload, Impl: IDownloadBehavior_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pdispcallback: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -672,17 +672,17 @@ impl IHTMLPersistData_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IHTMLPersistDataOM_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn XMLDocument(&self) -> ::windows_core::Result; - fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; - fn setAttribute(&self, name: &::windows_core::BSTR, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setAttribute(&self, name: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn removeAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IHTMLPersistDataOM {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IHTMLPersistDataOM_Vtbl { pub const fn new, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>() -> IHTMLPersistDataOM_Vtbl { unsafe extern "system" fn XMLDocument, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -696,7 +696,7 @@ impl IHTMLPersistDataOM_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn getAttribute, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getAttribute, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getAttribute(::core::mem::transmute(&name)) { @@ -707,7 +707,7 @@ impl IHTMLPersistDataOM_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setAttribute, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttribute, Impl: IHTMLPersistDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute(&name), ::core::mem::transmute(&value)).into() @@ -729,21 +729,21 @@ impl IHTMLPersistDataOM_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IHTMLUserDataOM_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn XMLDocument(&self) -> ::windows_core::Result; fn save(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn load(&self, strname: &::windows_core::BSTR) -> ::windows_core::Result<()>; - fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result; - fn setAttribute(&self, name: &::windows_core::BSTR, value: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn getAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::VARIANT>; + fn setAttribute(&self, name: &::windows_core::BSTR, value: &::windows_core::VARIANT) -> ::windows_core::Result<()>; fn removeAttribute(&self, name: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn Setexpires(&self, bstr: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn expires(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IHTMLUserDataOM {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IHTMLUserDataOM_Vtbl { pub const fn new, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>() -> IHTMLUserDataOM_Vtbl { unsafe extern "system" fn XMLDocument, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -767,7 +767,7 @@ impl IHTMLUserDataOM_Vtbl { let this = (*this).get_impl(); this.load(::core::mem::transmute(&strname)).into() } - unsafe extern "system" fn getAttribute, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn getAttribute, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.getAttribute(::core::mem::transmute(&name)) { @@ -778,7 +778,7 @@ impl IHTMLUserDataOM_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn setAttribute, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn setAttribute, Impl: IHTMLUserDataOM_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.setAttribute(::core::mem::transmute(&name), ::core::mem::transmute(&value)).into() @@ -820,8 +820,8 @@ impl IHTMLUserDataOM_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IHeaderFooter_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn htmlHead(&self) -> ::windows_core::Result<::windows_core::BSTR>; fn htmlFoot(&self) -> ::windows_core::Result<::windows_core::BSTR>; @@ -846,9 +846,9 @@ pub trait IHeaderFooter_Impl: Sized + super::super::System::Com::IDispatch_Impl fn SettimeLong(&self, v: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn timeLong(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IHeaderFooter {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IHeaderFooter_Vtbl { pub const fn new, Impl: IHeaderFooter_Impl, const OFFSET: isize>() -> IHeaderFooter_Vtbl { unsafe extern "system" fn htmlHead, Impl: IHeaderFooter_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, p: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1063,15 +1063,15 @@ impl IHeaderFooter_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IHeaderFooter2_Impl: Sized + IHeaderFooter_Impl { fn Setfont(&self, v: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn font(&self) -> ::windows_core::Result<::windows_core::BSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IHeaderFooter2 {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IHeaderFooter2_Vtbl { pub const fn new, Impl: IHeaderFooter2_Impl, const OFFSET: isize>() -> IHeaderFooter2_Vtbl { unsafe extern "system" fn Setfont, Impl: IHeaderFooter2_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, v: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1096,16 +1096,16 @@ impl IHeaderFooter2_Vtbl { iid == &::IID || iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IHomePage_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn navigateHomePage(&self) -> ::windows_core::Result<()>; fn setHomePage(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn isHomePage(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IHomePage {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IHomePage_Vtbl { pub const fn new, Impl: IHomePage_Impl, const OFFSET: isize>() -> IHomePage_Vtbl { unsafe extern "system" fn navigateHomePage, Impl: IHomePage_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT { @@ -1180,14 +1180,14 @@ impl IHomePageSetting_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIEWebDriverManager_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn ExecuteCommand(&self, command: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::PWSTR>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIEWebDriverManager {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIEWebDriverManager_Vtbl { pub const fn new, Impl: IIEWebDriverManager_Impl, const OFFSET: isize>() -> IIEWebDriverManager_Vtbl { unsafe extern "system" fn ExecuteCommand, Impl: IIEWebDriverManager_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, command: ::windows_core::PCWSTR, response: *mut ::windows_core::PWSTR) -> ::windows_core::HRESULT { @@ -1207,16 +1207,16 @@ impl IIEWebDriverManager_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIEWebDriverSite_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn WindowOperation(&self, operationcode: u32, hwnd: u32) -> ::windows_core::Result<()>; fn DetachWebdriver(&self, punkwd: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; - fn GetCapabilityValue(&self, punkwd: ::core::option::Option<&::windows_core::IUnknown>, capname: &::windows_core::PCWSTR) -> ::windows_core::Result; + fn GetCapabilityValue(&self, punkwd: ::core::option::Option<&::windows_core::IUnknown>, capname: &::windows_core::PCWSTR) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIEWebDriverSite {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIEWebDriverSite_Vtbl { pub const fn new, Impl: IIEWebDriverSite_Impl, const OFFSET: isize>() -> IIEWebDriverSite_Vtbl { unsafe extern "system" fn WindowOperation, Impl: IIEWebDriverSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, operationcode: u32, hwnd: u32) -> ::windows_core::HRESULT { @@ -1229,7 +1229,7 @@ impl IIEWebDriverSite_Vtbl { let this = (*this).get_impl(); this.DetachWebdriver(::windows_core::from_raw_borrowed(&punkwd)).into() } - unsafe extern "system" fn GetCapabilityValue, Impl: IIEWebDriverSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkwd: *mut ::core::ffi::c_void, capname: ::windows_core::PCWSTR, capvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetCapabilityValue, Impl: IIEWebDriverSite_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, punkwd: *mut ::core::ffi::c_void, capname: ::windows_core::PCWSTR, capvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetCapabilityValue(::windows_core::from_raw_borrowed(&punkwd), ::core::mem::transmute(&capname)) { @@ -1373,15 +1373,15 @@ impl IImageDecodeFilter_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait IIntelliForms_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn enabled(&self) -> ::windows_core::Result; fn Setenabled(&self, bval: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for IIntelliForms {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl IIntelliForms_Vtbl { pub const fn new, Impl: IIntelliForms_Impl, const OFFSET: isize>() -> IIntelliForms_Vtbl { unsafe extern "system" fn enabled, Impl: IIntelliForms_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pval: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT { @@ -1450,13 +1450,13 @@ impl IInternetExplorerManager2_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait ILayoutRect_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn SetnextRect(&self, bstrelementid: &::windows_core::BSTR) -> ::windows_core::Result<()>; fn nextRect(&self) -> ::windows_core::Result<::windows_core::BSTR>; - fn SetcontentSrc(&self, varcontentsrc: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; - fn contentSrc(&self) -> ::windows_core::Result; + fn SetcontentSrc(&self, varcontentsrc: &::windows_core::VARIANT) -> ::windows_core::Result<()>; + fn contentSrc(&self) -> ::windows_core::Result<::windows_core::VARIANT>; fn SethonorPageBreaks(&self, v: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; fn honorPageBreaks(&self) -> ::windows_core::Result; fn SethonorPageRules(&self, v: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::Result<()>; @@ -1465,9 +1465,9 @@ pub trait ILayoutRect_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn nextRectElement(&self) -> ::windows_core::Result; fn contentDocument(&self) -> ::windows_core::Result; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for ILayoutRect {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ILayoutRect_Vtbl { pub const fn new, Impl: ILayoutRect_Impl, const OFFSET: isize>() -> ILayoutRect_Vtbl { unsafe extern "system" fn SetnextRect, Impl: ILayoutRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrelementid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { @@ -1486,12 +1486,12 @@ impl ILayoutRect_Vtbl { ::core::result::Result::Err(err) => err.into(), } } - unsafe extern "system" fn SetcontentSrc, Impl: ILayoutRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varcontentsrc: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn SetcontentSrc, Impl: ILayoutRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, varcontentsrc: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.SetcontentSrc(::core::mem::transmute(&varcontentsrc)).into() } - unsafe extern "system" fn contentSrc, Impl: ILayoutRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcontentsrc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn contentSrc, Impl: ILayoutRect_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvarcontentsrc: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.contentSrc() { @@ -2951,20 +2951,16 @@ impl ITargetNotify2_Vtbl { iid == &::IID || iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITimer_Impl: Sized { - fn Advise(&self, vtimemin: &super::super::System::Variant::VARIANT, vtimemax: &super::super::System::Variant::VARIANT, vtimeinterval: &super::super::System::Variant::VARIANT, dwflags: u32, ptimersink: ::core::option::Option<&ITimerSink>) -> ::windows_core::Result; + fn Advise(&self, vtimemin: &::windows_core::VARIANT, vtimemax: &::windows_core::VARIANT, vtimeinterval: &::windows_core::VARIANT, dwflags: u32, ptimersink: ::core::option::Option<&ITimerSink>) -> ::windows_core::Result; fn Unadvise(&self, dwcookie: u32) -> ::windows_core::Result<()>; fn Freeze(&self, ffreeze: super::super::Foundation::BOOL) -> ::windows_core::Result<()>; - fn GetTime(&self) -> ::windows_core::Result; + fn GetTime(&self) -> ::windows_core::Result<::windows_core::VARIANT>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITimer {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITimer_Vtbl { pub const fn new, Impl: ITimer_Impl, const OFFSET: isize>() -> ITimer_Vtbl { - unsafe extern "system" fn Advise, Impl: ITimer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtimemin: super::super::System::Variant::VARIANT, vtimemax: super::super::System::Variant::VARIANT, vtimeinterval: super::super::System::Variant::VARIANT, dwflags: u32, ptimersink: *mut ::core::ffi::c_void, pdwcookie: *mut u32) -> ::windows_core::HRESULT { + unsafe extern "system" fn Advise, Impl: ITimer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtimemin: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vtimemax: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vtimeinterval: ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwflags: u32, ptimersink: *mut ::core::ffi::c_void, pdwcookie: *mut u32) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.Advise(::core::mem::transmute(&vtimemin), ::core::mem::transmute(&vtimemax), ::core::mem::transmute(&vtimeinterval), ::core::mem::transmute_copy(&dwflags), ::windows_core::from_raw_borrowed(&ptimersink)) { @@ -2985,7 +2981,7 @@ impl ITimer_Vtbl { let this = (*this).get_impl(); this.Freeze(::core::mem::transmute_copy(&ffreeze)).into() } - unsafe extern "system" fn GetTime, Impl: ITimer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn GetTime, Impl: ITimer_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, pvtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); match this.GetTime() { @@ -3008,14 +3004,10 @@ impl ITimer_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITimerEx_Impl: Sized + ITimer_Impl { fn SetMode(&self, dwmode: u32) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITimerEx {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITimerEx_Vtbl { pub const fn new, Impl: ITimerEx_Impl, const OFFSET: isize>() -> ITimerEx_Vtbl { unsafe extern "system" fn SetMode, Impl: ITimerEx_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, dwmode: u32) -> ::windows_core::HRESULT { @@ -3075,17 +3067,13 @@ impl ITimerService_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] pub trait ITimerSink_Impl: Sized { - fn OnTimer(&self, vtimeadvise: &super::super::System::Variant::VARIANT) -> ::windows_core::Result<()>; + fn OnTimer(&self, vtimeadvise: &::windows_core::VARIANT) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ::windows_core::RuntimeName for ITimerSink {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] impl ITimerSink_Vtbl { pub const fn new, Impl: ITimerSink_Impl, const OFFSET: isize>() -> ITimerSink_Vtbl { - unsafe extern "system" fn OnTimer, Impl: ITimerSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtimeadvise: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT { + unsafe extern "system" fn OnTimer, Impl: ITimerSink_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, vtimeadvise: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT { let this = (this as *const *const ()).offset(OFFSET) as *const Identity; let this = (*this).get_impl(); this.OnTimer(::core::mem::transmute(&vtimeadvise)).into() @@ -3150,12 +3138,12 @@ impl ITridentTouchInputSite_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Ole\"`"] +#[cfg(feature = "Win32_System_Ole")] pub trait IUrlHistoryNotify_Impl: Sized + super::super::System::Ole::IOleCommandTarget_Impl {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Ole")] impl ::windows_core::RuntimeName for IUrlHistoryNotify {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Ole")] impl IUrlHistoryNotify_Vtbl { pub const fn new, Impl: IUrlHistoryNotify_Impl, const OFFSET: isize>() -> IUrlHistoryNotify_Vtbl { Self { base__: super::super::System::Ole::IOleCommandTarget_Vtbl::new::() } @@ -3510,16 +3498,16 @@ impl IWebBrowserEventsUrlService_Vtbl { iid == &::IID } } -#[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[doc = "Required features: `\"Win32_System_Com\"`"] +#[cfg(feature = "Win32_System_Com")] pub trait Iwfolders_Impl: Sized + super::super::System::Com::IDispatch_Impl { fn navigate(&self, bstrurl: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn navigateFrame(&self, bstrurl: &::windows_core::BSTR, bstrtargetframe: &::windows_core::BSTR) -> ::windows_core::Result<::windows_core::BSTR>; fn navigateNoSite(&self, bstrurl: &::windows_core::BSTR, bstrtargetframe: &::windows_core::BSTR, dwhwnd: u32, pwb: ::core::option::Option<&::windows_core::IUnknown>) -> ::windows_core::Result<()>; } -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl ::windows_core::RuntimeName for Iwfolders {} -#[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] +#[cfg(feature = "Win32_System_Com")] impl Iwfolders_Vtbl { pub const fn new, Impl: Iwfolders_Impl, const OFFSET: isize>() -> Iwfolders_Vtbl { unsafe extern "system" fn navigate, Impl: Iwfolders_Impl, const OFFSET: isize>(this: *mut ::core::ffi::c_void, bstrurl: ::std::mem::MaybeUninit<::windows_core::BSTR>, pbstrretval: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT { diff --git a/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/mod.rs b/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/mod.rs index 6d6c7d83d3..56dda3dfaa 100644 --- a/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/mod.rs +++ b/crates/libs/windows/src/Windows/Win32/Web/InternetExplorer/mod.rs @@ -990,22 +990,19 @@ impl IHTMLPersistDataOM { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).XMLDocument)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttribute(&self, name: P0, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setAttribute(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } pub unsafe fn removeAttribute(&self, name: P0) -> ::windows_core::Result<()> where @@ -1023,14 +1020,8 @@ pub struct IHTMLPersistDataOM_Vtbl { pub XMLDocument: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, #[cfg(not(feature = "Win32_System_Com"))] XMLDocument: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getAttribute: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttribute: usize, + pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, } #[cfg(feature = "Win32_System_Com")] @@ -1062,22 +1053,19 @@ impl IHTMLUserDataOM { { (::windows_core::Interface::vtable(self).load)(::windows_core::Interface::as_raw(self), strname.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result + pub unsafe fn getAttribute(&self, name: P0) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).getAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn setAttribute(&self, name: P0, value: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> + pub unsafe fn setAttribute(&self, name: P0, value: P1) -> ::windows_core::Result<()> where P0: ::windows_core::IntoParam<::windows_core::BSTR>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, { - (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), ::core::mem::transmute(value)).ok() + (::windows_core::Interface::vtable(self).setAttribute)(::windows_core::Interface::as_raw(self), name.into_param().abi(), value.into_param().abi()).ok() } pub unsafe fn removeAttribute(&self, name: P0) -> ::windows_core::Result<()> where @@ -1107,14 +1095,8 @@ pub struct IHTMLUserDataOM_Vtbl { XMLDocument: usize, pub save: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub load: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, strname: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - getAttribute: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - setAttribute: usize, + pub getAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, pvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub setAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>, value: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub removeAttribute: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, name: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub Setexpires: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstr: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub expires: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstr: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, @@ -1506,9 +1488,7 @@ impl IIEWebDriverSite { { (::windows_core::Interface::vtable(self).DetachWebdriver)(::windows_core::Interface::as_raw(self), punkwd.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetCapabilityValue(&self, punkwd: P0, capname: P1) -> ::windows_core::Result + pub unsafe fn GetCapabilityValue(&self, punkwd: P0, capname: P1) -> ::windows_core::Result<::windows_core::VARIANT> where P0: ::windows_core::IntoParam<::windows_core::IUnknown>, P1: ::windows_core::IntoParam<::windows_core::PCWSTR>, @@ -1524,10 +1504,7 @@ pub struct IIEWebDriverSite_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub WindowOperation: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, operationcode: u32, hwnd: u32) -> ::windows_core::HRESULT, pub DetachWebdriver: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkwd: *mut ::core::ffi::c_void) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetCapabilityValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkwd: *mut ::core::ffi::c_void, capname: ::windows_core::PCWSTR, capvalue: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetCapabilityValue: usize, + pub GetCapabilityValue: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, punkwd: *mut ::core::ffi::c_void, capname: ::windows_core::PCWSTR, capvalue: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(IImageDecodeEventSink, IImageDecodeEventSink_Vtbl, 0xbaa342a0_2ded_11d0_86f4_00a0c913f750); ::windows_core::imp::interface_hierarchy!(IImageDecodeEventSink, ::windows_core::IUnknown); @@ -1717,14 +1694,13 @@ impl ILayoutRect { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).nextRect)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn SetcontentSrc(&self, varcontentsrc: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).SetcontentSrc)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(varcontentsrc)).ok() + pub unsafe fn SetcontentSrc(&self, varcontentsrc: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).SetcontentSrc)(::windows_core::Interface::as_raw(self), varcontentsrc.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn contentSrc(&self) -> ::windows_core::Result { + pub unsafe fn contentSrc(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).contentSrc)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -1776,14 +1752,8 @@ pub struct ILayoutRect_Vtbl { pub base__: super::super::System::Com::IDispatch_Vtbl, pub SetnextRect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, bstrelementid: ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, pub nextRect: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pbstrelementid: *mut ::std::mem::MaybeUninit<::windows_core::BSTR>) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub SetcontentSrc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varcontentsrc: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - SetcontentSrc: usize, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub contentSrc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcontentsrc: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - contentSrc: usize, + pub SetcontentSrc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, varcontentsrc: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, + pub contentSrc: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvarcontentsrc: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, pub SethonorPageBreaks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub honorPageBreaks: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, p: *mut super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, pub SethonorPageRules: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, v: super::super::Foundation::VARIANT_BOOL) -> ::windows_core::HRESULT, @@ -2811,14 +2781,15 @@ pub struct ITargetNotify2_Vtbl { ::windows_core::imp::com_interface!(ITimer, ITimer_Vtbl, 0x3050f360_98b5_11cf_bb82_00aa00bdce0b); ::windows_core::imp::interface_hierarchy!(ITimer, ::windows_core::IUnknown); impl ITimer { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Advise(&self, vtimemin: super::super::System::Variant::VARIANT, vtimemax: super::super::System::Variant::VARIANT, vtimeinterval: super::super::System::Variant::VARIANT, dwflags: u32, ptimersink: P0) -> ::windows_core::Result + pub unsafe fn Advise(&self, vtimemin: P0, vtimemax: P1, vtimeinterval: P2, dwflags: u32, ptimersink: P3) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).Advise)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtimemin), ::core::mem::transmute(vtimemax), ::core::mem::transmute(vtimeinterval), dwflags, ptimersink.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).Advise)(::windows_core::Interface::as_raw(self), vtimemin.into_param().abi(), vtimemax.into_param().abi(), vtimeinterval.into_param().abi(), dwflags, ptimersink.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Unadvise(&self, dwcookie: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).Unadvise)(::windows_core::Interface::as_raw(self), dwcookie).ok() @@ -2829,9 +2800,7 @@ impl ITimer { { (::windows_core::Interface::vtable(self).Freeze)(::windows_core::Interface::as_raw(self), ffreeze.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetTime(&self) -> ::windows_core::Result { + pub unsafe fn GetTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).GetTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2840,28 +2809,23 @@ impl ITimer { #[doc(hidden)] pub struct ITimer_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub Advise: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtimemin: super::super::System::Variant::VARIANT, vtimemax: super::super::System::Variant::VARIANT, vtimeinterval: super::super::System::Variant::VARIANT, dwflags: u32, ptimersink: *mut ::core::ffi::c_void, pdwcookie: *mut u32) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - Advise: usize, + pub Advise: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtimemin: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vtimemax: ::std::mem::MaybeUninit<::windows_core::VARIANT>, vtimeinterval: ::std::mem::MaybeUninit<::windows_core::VARIANT>, dwflags: u32, ptimersink: *mut ::core::ffi::c_void, pdwcookie: *mut u32) -> ::windows_core::HRESULT, pub Unadvise: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, dwcookie: u32) -> ::windows_core::HRESULT, pub Freeze: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, ffreeze: super::super::Foundation::BOOL) -> ::windows_core::HRESULT, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub GetTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtime: *mut super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - GetTime: usize, + pub GetTime: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, pvtime: *mut ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITimerEx, ITimerEx_Vtbl, 0x30510414_98b5_11cf_bb82_00aa00bdce0b); ::windows_core::imp::interface_hierarchy!(ITimerEx, ::windows_core::IUnknown, ITimer); impl ITimerEx { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Advise(&self, vtimemin: super::super::System::Variant::VARIANT, vtimemax: super::super::System::Variant::VARIANT, vtimeinterval: super::super::System::Variant::VARIANT, dwflags: u32, ptimersink: P0) -> ::windows_core::Result + pub unsafe fn Advise(&self, vtimemin: P0, vtimemax: P1, vtimeinterval: P2, dwflags: u32, ptimersink: P3) -> ::windows_core::Result where - P0: ::windows_core::IntoParam, + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + P1: ::windows_core::IntoParam<::windows_core::VARIANT>, + P2: ::windows_core::IntoParam<::windows_core::VARIANT>, + P3: ::windows_core::IntoParam, { let mut result__ = ::std::mem::zeroed(); - (::windows_core::Interface::vtable(self).base__.Advise)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtimemin), ::core::mem::transmute(vtimemax), ::core::mem::transmute(vtimeinterval), dwflags, ptimersink.into_param().abi(), &mut result__).from_abi(result__) + (::windows_core::Interface::vtable(self).base__.Advise)(::windows_core::Interface::as_raw(self), vtimemin.into_param().abi(), vtimemax.into_param().abi(), vtimeinterval.into_param().abi(), dwflags, ptimersink.into_param().abi(), &mut result__).from_abi(result__) } pub unsafe fn Unadvise(&self, dwcookie: u32) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.Unadvise)(::windows_core::Interface::as_raw(self), dwcookie).ok() @@ -2872,9 +2836,7 @@ impl ITimerEx { { (::windows_core::Interface::vtable(self).base__.Freeze)(::windows_core::Interface::as_raw(self), ffreeze.into_param().abi()).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn GetTime(&self) -> ::windows_core::Result { + pub unsafe fn GetTime(&self) -> ::windows_core::Result<::windows_core::VARIANT> { let mut result__ = ::std::mem::zeroed(); (::windows_core::Interface::vtable(self).base__.GetTime)(::windows_core::Interface::as_raw(self), &mut result__).from_abi(result__) } @@ -2920,20 +2882,18 @@ pub struct ITimerService_Vtbl { ::windows_core::imp::com_interface!(ITimerSink, ITimerSink_Vtbl, 0x3050f361_98b5_11cf_bb82_00aa00bdce0b); ::windows_core::imp::interface_hierarchy!(ITimerSink, ::windows_core::IUnknown); impl ITimerSink { - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn OnTimer(&self, vtimeadvise: super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).OnTimer)(::windows_core::Interface::as_raw(self), ::core::mem::transmute(vtimeadvise)).ok() + pub unsafe fn OnTimer(&self, vtimeadvise: P0) -> ::windows_core::Result<()> + where + P0: ::windows_core::IntoParam<::windows_core::VARIANT>, + { + (::windows_core::Interface::vtable(self).OnTimer)(::windows_core::Interface::as_raw(self), vtimeadvise.into_param().abi()).ok() } } #[repr(C)] #[doc(hidden)] pub struct ITimerSink_Vtbl { pub base__: ::windows_core::IUnknown_Vtbl, - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub OnTimer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtimeadvise: super::super::System::Variant::VARIANT) -> ::windows_core::HRESULT, - #[cfg(not(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant")))] - OnTimer: usize, + pub OnTimer: unsafe extern "system" fn(this: *mut ::core::ffi::c_void, vtimeadvise: ::std::mem::MaybeUninit<::windows_core::VARIANT>) -> ::windows_core::HRESULT, } ::windows_core::imp::com_interface!(ITridentTouchInput, ITridentTouchInput_Vtbl, 0x30510850_98b5_11cf_bb82_00aa00bdce0b); ::windows_core::imp::interface_hierarchy!(ITridentTouchInput, ::windows_core::IUnknown); @@ -2991,10 +2951,10 @@ impl IUrlHistoryNotify { pub unsafe fn QueryStatus(&self, pguidcmdgroup: *const ::windows_core::GUID, ccmds: u32, prgcmds: *mut super::super::System::Ole::OLECMD, pcmdtext: *mut super::super::System::Ole::OLECMDTEXT) -> ::windows_core::Result<()> { (::windows_core::Interface::vtable(self).base__.QueryStatus)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ccmds, prgcmds, pcmdtext).ok() } - #[doc = "Required features: `\"Win32_System_Com\"`, `\"Win32_System_Ole\"`, `\"Win32_System_Variant\"`"] - #[cfg(all(feature = "Win32_System_Com", feature = "Win32_System_Ole", feature = "Win32_System_Variant"))] - pub unsafe fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const super::super::System::Variant::VARIANT, pvaout: *mut super::super::System::Variant::VARIANT) -> ::windows_core::Result<()> { - (::windows_core::Interface::vtable(self).base__.Exec)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ncmdid, ncmdexecopt, pvain, pvaout).ok() + #[doc = "Required features: `\"Win32_System_Ole\"`"] + #[cfg(feature = "Win32_System_Ole")] + pub unsafe fn Exec(&self, pguidcmdgroup: *const ::windows_core::GUID, ncmdid: u32, ncmdexecopt: u32, pvain: *const ::windows_core::VARIANT, pvaout: *mut ::windows_core::VARIANT) -> ::windows_core::Result<()> { + (::windows_core::Interface::vtable(self).base__.Exec)(::windows_core::Interface::as_raw(self), pguidcmdgroup, ncmdid, ncmdexecopt, ::core::mem::transmute(pvain), ::core::mem::transmute(pvaout)).ok() } } #[cfg(feature = "Win32_System_Ole")] diff --git a/crates/tests/implement/tests/properties.rs b/crates/tests/implement/tests/properties.rs index c7db81f07c..c577e15250 100644 --- a/crates/tests/implement/tests/properties.rs +++ b/crates/tests/implement/tests/properties.rs @@ -1,12 +1,9 @@ #![allow(non_snake_case)] -use windows::{ - core::*, Win32::System::Com::StructuredStorage::*, Win32::System::Com::*, - Win32::UI::Shell::PropertiesSystem::*, -}; +use windows::{core::*, Win32::System::Com::*, Win32::UI::Shell::PropertiesSystem::*}; #[implement(IInitializeWithStream, IPropertyStore, IPropertyStoreCapabilities)] -struct Object(); +struct Object(std::sync::RwLock); impl IInitializeWithStream_Impl for Object { fn Initialize(&self, _: Option<&IStream>, _: u32) -> Result<()> { @@ -22,10 +19,13 @@ impl IPropertyStore_Impl for Object { unimplemented!() } fn GetValue(&self, _: *const PROPERTYKEY) -> Result { - unimplemented!() + let reader = self.0.read().unwrap(); + Ok(reader.clone()) } - fn SetValue(&self, _: *const PROPERTYKEY, _: *const PROPVARIANT) -> Result<()> { - unimplemented!() + fn SetValue(&self, _: *const PROPERTYKEY, value: *const PROPVARIANT) -> Result<()> { + let mut writer = self.0.write().unwrap(); + *writer = unsafe { (*value).clone() }; + Ok(()) } fn Commit(&self) -> Result<()> { unimplemented!() @@ -41,12 +41,15 @@ impl IPropertyStoreCapabilities_Impl for Object { #[test] fn test() -> Result<()> { unsafe { - let a: IInitializeWithStream = Object().into(); + let a: IInitializeWithStream = Object(std::sync::RwLock::new(Default::default())).into(); a.Initialize(None, 0)?; let b: IPropertyStore = a.cast()?; assert!(b.GetCount()? == 123); + b.SetValue(std::ptr::null(), &PROPVARIANT::from(123))?; + assert_eq!(PROPVARIANT::from(123), b.GetValue(std::ptr::null())?); + let c: IPropertyStoreCapabilities = b.cast()?; c.IsPropertyWritable(&PROPERTYKEY::default())?; diff --git a/crates/tests/metadata/tests/unused.rs b/crates/tests/metadata/tests/unused.rs index ee6ae69be9..a70c257f7a 100644 --- a/crates/tests/metadata/tests/unused.rs +++ b/crates/tests/metadata/tests/unused.rs @@ -7,6 +7,7 @@ fn test() { files, &["Windows", "BadNamespace", "Windows.AI"], &["Windows.Foundation.Rect", "Windows.Foundation.BadType"], + &Default::default(), ); let unused: Vec<&str> = reader.unused().collect(); diff --git a/crates/tests/variant/Cargo.toml b/crates/tests/variant/Cargo.toml new file mode 100644 index 0000000000..2d34b26a59 --- /dev/null +++ b/crates/tests/variant/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "test_variant" +version = "0.0.0" +edition = "2021" +publish = false + +[dependencies.windows-core] +path = "../../libs/core" diff --git a/crates/tests/variant/src/lib.rs b/crates/tests/variant/src/lib.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/crates/tests/variant/src/lib.rs @@ -0,0 +1 @@ + diff --git a/crates/tests/variant/tests/tests.rs b/crates/tests/variant/tests/tests.rs new file mode 100644 index 0000000000..0fe860e5d0 --- /dev/null +++ b/crates/tests/variant/tests/tests.rs @@ -0,0 +1,193 @@ +use windows_core::*; + +#[test] +fn test_variant() -> Result<()> { + let empty: VARIANT = VARIANT::new(); + assert!(empty.is_empty()); + + let v = VARIANT::default(); + assert!(v.is_empty()); + + assert_eq!(VARIANT::new(), VARIANT::default()); + + let v = VARIANT::from(true); + assert!(!v.is_empty()); + assert_eq!(bool::try_from(&v)?, true); + let v = VARIANT::from(false); + assert_eq!(bool::try_from(&v)?, false); + assert_eq!(VARIANT::from(true), VARIANT::from(true)); + assert_eq!(VARIANT::from(false), VARIANT::from(false)); + assert_ne!(VARIANT::from(true), VARIANT::from(false)); + + let v = VARIANT::from(123u8); + assert_eq!(u16::try_from(&v)?, 123u16); + assert_eq!(VARIANT::from(123u8), VARIANT::from(123u8)); + assert_ne!(VARIANT::from(123u8), VARIANT::from(0u8)); + + let v = VARIANT::from(-123i8); + assert_eq!(i16::try_from(&v)?, -123i16); + assert_eq!(VARIANT::from(-123i8), VARIANT::from(-123i8)); + assert_ne!(VARIANT::from(-123i8), VARIANT::from(0i8)); + + let v = VARIANT::from(345u16); + assert_eq!(u16::try_from(&v)?, 345u16); + assert_eq!(VARIANT::from(345u16), VARIANT::from(345u16)); + assert_ne!(VARIANT::from(345u16), VARIANT::from(0u16)); + + let v = VARIANT::from(-345i16); + assert_eq!(i16::try_from(&v)?, -345i16); + assert_eq!(VARIANT::from(-345i16), VARIANT::from(-345i16)); + assert_ne!(VARIANT::from(-345i16), VARIANT::from(0i16)); + + let v = VARIANT::from(67890u32); + assert_eq!(u32::try_from(&v)?, 67890u32); + assert_eq!(VARIANT::from(67890u32), VARIANT::from(67890u32)); + assert_ne!(VARIANT::from(67890u32), VARIANT::from(0u32)); + + let v = VARIANT::from(-67890i32); + assert_eq!(i32::try_from(&v)?, -67890i32); + assert_eq!(VARIANT::from(-67890i32), VARIANT::from(-67890i32)); + assert_ne!(VARIANT::from(-67890i32), VARIANT::from(0i32)); + + let v = VARIANT::from(5294967295u64); + assert_eq!(u64::try_from(&v)?, 5294967295u64); + assert_eq!(VARIANT::from(5294967295u64), VARIANT::from(5294967295u64)); + assert_ne!(VARIANT::from(5294967295u64), VARIANT::from(0u64)); + + let v = VARIANT::from(-5294967295i64); + assert_eq!(i64::try_from(&v)?, -5294967295i64); + assert_eq!(VARIANT::from(-5294967295i64), VARIANT::from(-5294967295i64)); + assert_ne!(VARIANT::from(-5294967295i64), VARIANT::from(0i64)); + + let v = VARIANT::from(3.5f32); + assert_eq!(f64::try_from(&v)?, 3.5f64); + assert_eq!(VARIANT::from(3.5f32), VARIANT::from(3.5f32)); + assert_ne!(VARIANT::from(3.5f32), VARIANT::from(0.0f32)); + + let v = VARIANT::from(3.5f64); + assert_eq!(f64::try_from(&v)?, 3.5f64); + assert_eq!(VARIANT::from(3.5f64), VARIANT::from(3.5f64)); + assert_ne!(VARIANT::from(3.5f64), VARIANT::from(0.0f64)); + + let v = VARIANT::from(BSTR::from("hello")); + assert_eq!(BSTR::try_from(&v)?, "hello"); + assert_eq!( + VARIANT::from(BSTR::from("hello")), + VARIANT::from(BSTR::from("hello")) + ); + assert_ne!( + VARIANT::from(BSTR::from("hello")), + VARIANT::from(BSTR::from("goodbye")) + ); + + let v = VARIANT::from(3.5f64); + assert_eq!(BSTR::try_from(&v)?, "3.5"); + + assert_eq!(format!("{v:?}"), "VARIANT { type: 5, value: 3.5 }"); + + let clone = v.clone(); + assert_eq!(v, clone); + assert_eq!(v, VARIANT::from(3.5f64)); + assert_ne!(v, VARIANT::from(true)); + + Ok(()) +} + +#[test] +fn test_propvariant() -> Result<()> { + let empty: PROPVARIANT = PROPVARIANT::new(); + assert!(empty.is_empty()); + + let v = PROPVARIANT::default(); + assert!(v.is_empty()); + + assert_eq!(PROPVARIANT::new(), PROPVARIANT::default()); + + let v = PROPVARIANT::from(true); + assert!(!v.is_empty()); + assert_eq!(bool::try_from(&v)?, true); + let v = PROPVARIANT::from(false); + assert_eq!(bool::try_from(&v)?, false); + assert_eq!(PROPVARIANT::from(true), PROPVARIANT::from(true)); + assert_eq!(PROPVARIANT::from(false), PROPVARIANT::from(false)); + assert_ne!(PROPVARIANT::from(true), PROPVARIANT::from(false)); + + let v = PROPVARIANT::from(123u8); + assert_eq!(u16::try_from(&v)?, 123u16); + assert_eq!(PROPVARIANT::from(123u8), PROPVARIANT::from(123u8)); + assert_ne!(PROPVARIANT::from(123u8), PROPVARIANT::from(0u8)); + + let v = PROPVARIANT::from(-123i8); + assert_eq!(i16::try_from(&v)?, -123i16); + assert_eq!(PROPVARIANT::from(-123i8), PROPVARIANT::from(-123i8)); + assert_ne!(PROPVARIANT::from(-123i8), PROPVARIANT::from(0i8)); + + let v = PROPVARIANT::from(345u16); + assert_eq!(u16::try_from(&v)?, 345u16); + assert_eq!(PROPVARIANT::from(345u16), PROPVARIANT::from(345u16)); + assert_ne!(PROPVARIANT::from(345u16), PROPVARIANT::from(0u16)); + + let v = PROPVARIANT::from(-345i16); + assert_eq!(i16::try_from(&v)?, -345i16); + assert_eq!(PROPVARIANT::from(-345i16), PROPVARIANT::from(-345i16)); + assert_ne!(PROPVARIANT::from(-345i16), PROPVARIANT::from(0i16)); + + let v = PROPVARIANT::from(67890u32); + assert_eq!(u32::try_from(&v)?, 67890u32); + assert_eq!(PROPVARIANT::from(67890u32), PROPVARIANT::from(67890u32)); + assert_ne!(PROPVARIANT::from(67890u32), PROPVARIANT::from(0u32)); + + let v = PROPVARIANT::from(-67890i32); + assert_eq!(i32::try_from(&v)?, -67890i32); + assert_eq!(PROPVARIANT::from(-67890i32), PROPVARIANT::from(-67890i32)); + assert_ne!(PROPVARIANT::from(-67890i32), PROPVARIANT::from(0i32)); + + let v = PROPVARIANT::from(5294967295u64); + assert_eq!(u64::try_from(&v)?, 5294967295u64); + assert_eq!( + PROPVARIANT::from(5294967295u64), + PROPVARIANT::from(5294967295u64) + ); + assert_ne!(PROPVARIANT::from(5294967295u64), PROPVARIANT::from(0u64)); + + let v = PROPVARIANT::from(-5294967295i64); + assert_eq!(i64::try_from(&v)?, -5294967295i64); + assert_eq!( + PROPVARIANT::from(-5294967295i64), + PROPVARIANT::from(-5294967295i64) + ); + assert_ne!(PROPVARIANT::from(-5294967295i64), PROPVARIANT::from(0i64)); + + let v = PROPVARIANT::from(3.5f32); + assert_eq!(f64::try_from(&v)?, 3.5f64); + assert_eq!(PROPVARIANT::from(3.5f32), PROPVARIANT::from(3.5f32)); + assert_ne!(PROPVARIANT::from(3.5f32), PROPVARIANT::from(0.0f32)); + + let v = PROPVARIANT::from(3.5f64); + assert_eq!(f64::try_from(&v)?, 3.5f64); + assert_eq!(PROPVARIANT::from(3.5f64), PROPVARIANT::from(3.5f64)); + assert_ne!(PROPVARIANT::from(3.5f64), PROPVARIANT::from(0.0f64)); + + let v = PROPVARIANT::from(BSTR::from("hello")); + assert_eq!(BSTR::try_from(&v)?, "hello"); + assert_eq!( + PROPVARIANT::from(BSTR::from("hello")), + PROPVARIANT::from(BSTR::from("hello")) + ); + assert_ne!( + PROPVARIANT::from(BSTR::from("hello")), + PROPVARIANT::from(BSTR::from("goodbye")) + ); + + let v = PROPVARIANT::from(3.5f64); + assert_eq!(BSTR::try_from(&v)?, "3.5"); + + assert_eq!(format!("{v:?}"), "PROPVARIANT { type: 5, value: 3.5 }"); + + let clone = v.clone(); + assert_eq!(v, clone); + assert_eq!(v, PROPVARIANT::from(3.5f64)); + assert_ne!(v, PROPVARIANT::from(true)); + + Ok(()) +} diff --git a/crates/tools/core/bindings.txt b/crates/tools/core/bindings.txt index 6f902cc929..1e73f4e69b 100644 --- a/crates/tools/core/bindings.txt +++ b/crates/tools/core/bindings.txt @@ -5,8 +5,8 @@ --filter Windows.Win32.Foundation.CloseHandle - Windows.Win32.Foundation.ERROR_NO_UNICODE_TRANSLATION Windows.Win32.Foundation.E_INVALIDARG + Windows.Win32.Foundation.ERROR_NO_UNICODE_TRANSLATION Windows.Win32.Foundation.FreeLibrary Windows.Win32.Foundation.GetLastError Windows.Win32.Foundation.SysAllocStringLen @@ -14,6 +14,21 @@ Windows.Win32.Foundation.SysStringLen Windows.Win32.System.Com.CoTaskMemAlloc Windows.Win32.System.Com.CoTaskMemFree + Windows.Win32.System.Com.StructuredStorage.PROPVARIANT + Windows.Win32.System.Com.StructuredStorage.PropVariantClear + Windows.Win32.System.Com.StructuredStorage.PropVariantCompareEx + Windows.Win32.System.Com.StructuredStorage.PropVariantCopy + Windows.Win32.System.Com.StructuredStorage.PropVariantToBoolean + Windows.Win32.System.Com.StructuredStorage.PropVariantToBSTR + Windows.Win32.System.Com.StructuredStorage.PropVariantToDouble + Windows.Win32.System.Com.StructuredStorage.PropVariantToInt16 + Windows.Win32.System.Com.StructuredStorage.PropVariantToInt32 + Windows.Win32.System.Com.StructuredStorage.PropVariantToInt64 + Windows.Win32.System.Com.StructuredStorage.PropVariantToUInt16 + Windows.Win32.System.Com.StructuredStorage.PropVariantToUInt32 + Windows.Win32.System.Com.StructuredStorage.PropVariantToUInt64 + Windows.Win32.System.Com.StructuredStorage.PropVariantToVariant + Windows.Win32.System.Com.StructuredStorage.VariantToPropVariant Windows.Win32.System.Diagnostics.Debug.EncodePointer Windows.Win32.System.Diagnostics.Debug.FORMAT_MESSAGE_ALLOCATE_BUFFER Windows.Win32.System.Diagnostics.Debug.FORMAT_MESSAGE_FROM_SYSTEM @@ -27,4 +42,28 @@ Windows.Win32.System.Memory.HeapFree Windows.Win32.System.Threading.CreateEventW Windows.Win32.System.Threading.SetEvent - Windows.Win32.System.Threading.WaitForSingleObject \ No newline at end of file + Windows.Win32.System.Threading.WaitForSingleObject + Windows.Win32.System.Variant.VARIANT + Windows.Win32.System.Variant.VariantClear + Windows.Win32.System.Variant.VariantCopy + Windows.Win32.System.Variant.VariantToBoolean + Windows.Win32.System.Variant.VariantToDouble + Windows.Win32.System.Variant.VariantToInt16 + Windows.Win32.System.Variant.VariantToInt32 + Windows.Win32.System.Variant.VariantToInt64 + Windows.Win32.System.Variant.VariantToUInt16 + Windows.Win32.System.Variant.VariantToUInt32 + Windows.Win32.System.Variant.VariantToUInt64 + Windows.Win32.System.Variant.VT_BOOL + Windows.Win32.System.Variant.VT_BSTR + Windows.Win32.System.Variant.VT_EMPTY + Windows.Win32.System.Variant.VT_I1 + Windows.Win32.System.Variant.VT_I2 + Windows.Win32.System.Variant.VT_I4 + Windows.Win32.System.Variant.VT_I8 + Windows.Win32.System.Variant.VT_R4 + Windows.Win32.System.Variant.VT_R8 + Windows.Win32.System.Variant.VT_UI1 + Windows.Win32.System.Variant.VT_UI2 + Windows.Win32.System.Variant.VT_UI4 + Windows.Win32.System.Variant.VT_UI8